1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/test/lgf_reader_writer_test.cc Tue Feb 12 07:15:52 2013 +0100
1.3 @@ -0,0 +1,578 @@
1.4 +/* -*- mode: C++; indent-tabs-mode: nil; -*-
1.5 + *
1.6 + * This file is a part of LEMON, a generic C++ optimization library.
1.7 + *
1.8 + * Copyright (C) 2003-2010
1.9 + * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
1.10 + * (Egervary Research Group on Combinatorial Optimization, EGRES).
1.11 + *
1.12 + * Permission to use, modify and distribute this software is granted
1.13 + * provided that this copyright notice appears in all copies. For
1.14 + * precise terms see the accompanying LICENSE file.
1.15 + *
1.16 + * This software is provided "AS IS" with no warranty of any kind,
1.17 + * express or implied, and with no claim as to its suitability for any
1.18 + * purpose.
1.19 + *
1.20 + */
1.21 +
1.22 +#include <string>
1.23 +
1.24 +#include <lemon/concepts/digraph.h>
1.25 +#include <lemon/concepts/graph.h>
1.26 +#include <lemon/concepts/bpgraph.h>
1.27 +
1.28 +#include <lemon/list_graph.h>
1.29 +#include <lemon/smart_graph.h>
1.30 +#include <lemon/lgf_reader.h>
1.31 +
1.32 +#include "test_tools.h"
1.33 +
1.34 +struct ReaderConverter {
1.35 + int operator()(const std::string& str) const {
1.36 + return str.length();
1.37 + }
1.38 +};
1.39 +
1.40 +struct WriterConverter {
1.41 + std::string operator()(int value) const {
1.42 + return std::string(value, '*');
1.43 + }
1.44 +};
1.45 +
1.46 +void checkDigraphReaderCompile() {
1.47 + typedef lemon::concepts::ExtendableDigraphComponent<
1.48 + lemon::concepts::Digraph> Digraph;
1.49 + Digraph digraph;
1.50 + Digraph::NodeMap<int> node_map(digraph);
1.51 + Digraph::ArcMap<int> arc_map(digraph);
1.52 + Digraph::Node node;
1.53 + Digraph::Arc arc;
1.54 + int attr;
1.55 +
1.56 + lemon::DigraphReader<Digraph> reader(digraph, "filename");
1.57 + reader.nodeMap("node_map", node_map);
1.58 + reader.nodeMap("node_map", node_map, ReaderConverter());
1.59 + reader.arcMap("arc_map", arc_map);
1.60 + reader.arcMap("arc_map", arc_map, ReaderConverter());
1.61 + reader.attribute("attr", attr);
1.62 + reader.attribute("attr", attr, ReaderConverter());
1.63 + reader.node("node", node);
1.64 + reader.arc("arc", arc);
1.65 +
1.66 + reader.nodes("alt_nodes_caption");
1.67 + reader.arcs("alt_arcs_caption");
1.68 + reader.attributes("alt_attrs_caption");
1.69 +
1.70 + reader.useNodes(node_map);
1.71 + reader.useNodes(node_map, WriterConverter());
1.72 + reader.useArcs(arc_map);
1.73 + reader.useArcs(arc_map, WriterConverter());
1.74 +
1.75 + reader.skipNodes();
1.76 + reader.skipArcs();
1.77 +
1.78 + reader.run();
1.79 +
1.80 + lemon::DigraphReader<Digraph> reader2(digraph, std::cin);
1.81 +}
1.82 +
1.83 +void checkDigraphWriterCompile() {
1.84 + typedef lemon::concepts::Digraph Digraph;
1.85 + Digraph digraph;
1.86 + Digraph::NodeMap<int> node_map(digraph);
1.87 + Digraph::ArcMap<int> arc_map(digraph);
1.88 + Digraph::Node node;
1.89 + Digraph::Arc arc;
1.90 + int attr;
1.91 +
1.92 + lemon::DigraphWriter<Digraph> writer(digraph, "filename");
1.93 + writer.nodeMap("node_map", node_map);
1.94 + writer.nodeMap("node_map", node_map, WriterConverter());
1.95 + writer.arcMap("arc_map", arc_map);
1.96 + writer.arcMap("arc_map", arc_map, WriterConverter());
1.97 + writer.attribute("attr", attr);
1.98 + writer.attribute("attr", attr, WriterConverter());
1.99 + writer.node("node", node);
1.100 + writer.arc("arc", arc);
1.101 +
1.102 + writer.nodes("alt_nodes_caption");
1.103 + writer.arcs("alt_arcs_caption");
1.104 + writer.attributes("alt_attrs_caption");
1.105 +
1.106 + writer.skipNodes();
1.107 + writer.skipArcs();
1.108 +
1.109 + writer.run();
1.110 +}
1.111 +
1.112 +void checkGraphReaderCompile() {
1.113 + typedef lemon::concepts::ExtendableGraphComponent<
1.114 + lemon::concepts::Graph> Graph;
1.115 + Graph graph;
1.116 + Graph::NodeMap<int> node_map(graph);
1.117 + Graph::ArcMap<int> arc_map(graph);
1.118 + Graph::EdgeMap<int> edge_map(graph);
1.119 + Graph::Node node;
1.120 + Graph::Arc arc;
1.121 + Graph::Edge edge;
1.122 + int attr;
1.123 +
1.124 + lemon::GraphReader<Graph> reader(graph, "filename");
1.125 + reader.nodeMap("node_map", node_map);
1.126 + reader.nodeMap("node_map", node_map, ReaderConverter());
1.127 + reader.arcMap("arc_map", arc_map);
1.128 + reader.arcMap("arc_map", arc_map, ReaderConverter());
1.129 + reader.edgeMap("edge_map", edge_map);
1.130 + reader.edgeMap("edge_map", edge_map, ReaderConverter());
1.131 + reader.attribute("attr", attr);
1.132 + reader.attribute("attr", attr, ReaderConverter());
1.133 + reader.node("node", node);
1.134 + reader.arc("arc", arc);
1.135 +
1.136 + reader.nodes("alt_nodes_caption");
1.137 + reader.edges("alt_edges_caption");
1.138 + reader.attributes("alt_attrs_caption");
1.139 +
1.140 + reader.useNodes(node_map);
1.141 + reader.useNodes(node_map, WriterConverter());
1.142 + reader.useEdges(edge_map);
1.143 + reader.useEdges(edge_map, WriterConverter());
1.144 +
1.145 + reader.skipNodes();
1.146 + reader.skipEdges();
1.147 +
1.148 + reader.run();
1.149 +
1.150 + lemon::GraphReader<Graph> reader2(graph, std::cin);
1.151 +}
1.152 +
1.153 +void checkGraphWriterCompile() {
1.154 + typedef lemon::concepts::Graph Graph;
1.155 + Graph graph;
1.156 + Graph::NodeMap<int> node_map(graph);
1.157 + Graph::ArcMap<int> arc_map(graph);
1.158 + Graph::EdgeMap<int> edge_map(graph);
1.159 + Graph::Node node;
1.160 + Graph::Arc arc;
1.161 + Graph::Edge edge;
1.162 + int attr;
1.163 +
1.164 + lemon::GraphWriter<Graph> writer(graph, "filename");
1.165 + writer.nodeMap("node_map", node_map);
1.166 + writer.nodeMap("node_map", node_map, WriterConverter());
1.167 + writer.arcMap("arc_map", arc_map);
1.168 + writer.arcMap("arc_map", arc_map, WriterConverter());
1.169 + writer.edgeMap("edge_map", edge_map);
1.170 + writer.edgeMap("edge_map", edge_map, WriterConverter());
1.171 + writer.attribute("attr", attr);
1.172 + writer.attribute("attr", attr, WriterConverter());
1.173 + writer.node("node", node);
1.174 + writer.arc("arc", arc);
1.175 + writer.edge("edge", edge);
1.176 +
1.177 + writer.nodes("alt_nodes_caption");
1.178 + writer.edges("alt_edges_caption");
1.179 + writer.attributes("alt_attrs_caption");
1.180 +
1.181 + writer.skipNodes();
1.182 + writer.skipEdges();
1.183 +
1.184 + writer.run();
1.185 +
1.186 + lemon::GraphWriter<Graph> writer2(graph, std::cout);
1.187 +}
1.188 +
1.189 +void checkBpGraphReaderCompile() {
1.190 + typedef lemon::concepts::ExtendableBpGraphComponent<
1.191 + lemon::concepts::BpGraph> BpGraph;
1.192 + BpGraph graph;
1.193 + BpGraph::NodeMap<int> node_map(graph);
1.194 + BpGraph::RedNodeMap<int> red_node_map(graph);
1.195 + BpGraph::BlueNodeMap<int> blue_node_map(graph);
1.196 + BpGraph::ArcMap<int> arc_map(graph);
1.197 + BpGraph::EdgeMap<int> edge_map(graph);
1.198 + BpGraph::Node node;
1.199 + BpGraph::RedNode red_node;
1.200 + BpGraph::BlueNode blue_node;
1.201 + BpGraph::Arc arc;
1.202 + BpGraph::Edge edge;
1.203 + int attr;
1.204 +
1.205 + lemon::BpGraphReader<BpGraph> reader(graph, "filename");
1.206 + reader.nodeMap("node_map", node_map);
1.207 + reader.nodeMap("node_map", node_map, ReaderConverter());
1.208 + reader.redNodeMap("red_node_map", red_node_map);
1.209 + reader.redNodeMap("red_node_map", red_node_map, ReaderConverter());
1.210 + reader.blueNodeMap("blue_node_map", blue_node_map);
1.211 + reader.blueNodeMap("blue_node_map", blue_node_map, ReaderConverter());
1.212 + reader.arcMap("arc_map", arc_map);
1.213 + reader.arcMap("arc_map", arc_map, ReaderConverter());
1.214 + reader.edgeMap("edge_map", edge_map);
1.215 + reader.edgeMap("edge_map", edge_map, ReaderConverter());
1.216 + reader.attribute("attr", attr);
1.217 + reader.attribute("attr", attr, ReaderConverter());
1.218 + reader.node("node", node);
1.219 + reader.redNode("red_node", red_node);
1.220 + reader.blueNode("blue_node", blue_node);
1.221 + reader.arc("arc", arc);
1.222 +
1.223 + reader.nodes("alt_nodes_caption");
1.224 + reader.edges("alt_edges_caption");
1.225 + reader.attributes("alt_attrs_caption");
1.226 +
1.227 + reader.useNodes(node_map);
1.228 + reader.useNodes(node_map, WriterConverter());
1.229 + reader.useEdges(edge_map);
1.230 + reader.useEdges(edge_map, WriterConverter());
1.231 +
1.232 + reader.skipNodes();
1.233 + reader.skipEdges();
1.234 +
1.235 + reader.run();
1.236 +
1.237 + lemon::BpGraphReader<BpGraph> reader2(graph, std::cin);
1.238 +}
1.239 +
1.240 +void checkBpGraphWriterCompile() {
1.241 + typedef lemon::concepts::BpGraph BpGraph;
1.242 + BpGraph graph;
1.243 + BpGraph::NodeMap<int> node_map(graph);
1.244 + BpGraph::RedNodeMap<int> red_node_map(graph);
1.245 + BpGraph::BlueNodeMap<int> blue_node_map(graph);
1.246 + BpGraph::ArcMap<int> arc_map(graph);
1.247 + BpGraph::EdgeMap<int> edge_map(graph);
1.248 + BpGraph::Node node;
1.249 + BpGraph::RedNode red_node;
1.250 + BpGraph::BlueNode blue_node;
1.251 + BpGraph::Arc arc;
1.252 + BpGraph::Edge edge;
1.253 + int attr;
1.254 +
1.255 + lemon::BpGraphWriter<BpGraph> writer(graph, "filename");
1.256 + writer.nodeMap("node_map", node_map);
1.257 + writer.nodeMap("node_map", node_map, WriterConverter());
1.258 + writer.redNodeMap("red_node_map", red_node_map);
1.259 + writer.redNodeMap("red_node_map", red_node_map, WriterConverter());
1.260 + writer.blueNodeMap("blue_node_map", blue_node_map);
1.261 + writer.blueNodeMap("blue_node_map", blue_node_map, WriterConverter());
1.262 + writer.arcMap("arc_map", arc_map);
1.263 + writer.arcMap("arc_map", arc_map, WriterConverter());
1.264 + writer.edgeMap("edge_map", edge_map);
1.265 + writer.edgeMap("edge_map", edge_map, WriterConverter());
1.266 + writer.attribute("attr", attr);
1.267 + writer.attribute("attr", attr, WriterConverter());
1.268 + writer.node("node", node);
1.269 + writer.redNode("red_node", red_node);
1.270 + writer.blueNode("blue_node", blue_node);
1.271 + writer.arc("arc", arc);
1.272 +
1.273 + writer.nodes("alt_nodes_caption");
1.274 + writer.edges("alt_edges_caption");
1.275 + writer.attributes("alt_attrs_caption");
1.276 +
1.277 + writer.skipNodes();
1.278 + writer.skipEdges();
1.279 +
1.280 + writer.run();
1.281 +
1.282 + lemon::BpGraphWriter<BpGraph> writer2(graph, std::cout);
1.283 +}
1.284 +
1.285 +void checkDigraphReaderWriter() {
1.286 + typedef lemon::SmartDigraph Digraph;
1.287 + Digraph digraph;
1.288 + Digraph::Node n1 = digraph.addNode();
1.289 + Digraph::Node n2 = digraph.addNode();
1.290 + Digraph::Node n3 = digraph.addNode();
1.291 +
1.292 + Digraph::Arc a1 = digraph.addArc(n1, n2);
1.293 + Digraph::Arc a2 = digraph.addArc(n2, n3);
1.294 +
1.295 + Digraph::NodeMap<int> node_map(digraph);
1.296 + node_map[n1] = 11;
1.297 + node_map[n2] = 12;
1.298 + node_map[n3] = 13;
1.299 +
1.300 + Digraph::ArcMap<int> arc_map(digraph);
1.301 + arc_map[a1] = 21;
1.302 + arc_map[a2] = 22;
1.303 +
1.304 + int attr = 100;
1.305 +
1.306 + std::ostringstream os;
1.307 + lemon::DigraphWriter<Digraph> writer(digraph, os);
1.308 +
1.309 + writer.nodeMap("node_map1", node_map);
1.310 + writer.nodeMap("node_map2", node_map, WriterConverter());
1.311 + writer.arcMap("arc_map1", arc_map);
1.312 + writer.arcMap("arc_map2", arc_map, WriterConverter());
1.313 + writer.node("node", n2);
1.314 + writer.arc("arc", a1);
1.315 + writer.attribute("attr1", attr);
1.316 + writer.attribute("attr2", attr, WriterConverter());
1.317 +
1.318 + writer.run();
1.319 +
1.320 + typedef lemon::ListDigraph ExpDigraph;
1.321 + ExpDigraph exp_digraph;
1.322 + ExpDigraph::NodeMap<int> exp_node_map1(exp_digraph);
1.323 + ExpDigraph::NodeMap<int> exp_node_map2(exp_digraph);
1.324 + ExpDigraph::ArcMap<int> exp_arc_map1(exp_digraph);
1.325 + ExpDigraph::ArcMap<int> exp_arc_map2(exp_digraph);
1.326 + ExpDigraph::Node exp_n2;
1.327 + ExpDigraph::Arc exp_a1;
1.328 + int exp_attr1;
1.329 + int exp_attr2;
1.330 +
1.331 + std::istringstream is(os.str());
1.332 + lemon::DigraphReader<ExpDigraph> reader(exp_digraph, is);
1.333 +
1.334 + reader.nodeMap("node_map1", exp_node_map1);
1.335 + reader.nodeMap("node_map2", exp_node_map2, ReaderConverter());
1.336 + reader.arcMap("arc_map1", exp_arc_map1);
1.337 + reader.arcMap("arc_map2", exp_arc_map2, ReaderConverter());
1.338 + reader.node("node", exp_n2);
1.339 + reader.arc("arc", exp_a1);
1.340 + reader.attribute("attr1", exp_attr1);
1.341 + reader.attribute("attr2", exp_attr2, ReaderConverter());
1.342 +
1.343 + reader.run();
1.344 +
1.345 + check(lemon::countNodes(exp_digraph) == 3, "Wrong number of nodes");
1.346 + check(lemon::countArcs(exp_digraph) == 2, "Wrong number of arcs");
1.347 + check(exp_node_map1[exp_n2] == 12, "Wrong map value");
1.348 + check(exp_node_map2[exp_n2] == 12, "Wrong map value");
1.349 + check(exp_arc_map1[exp_a1] == 21, "Wrong map value");
1.350 + check(exp_arc_map2[exp_a1] == 21, "Wrong map value");
1.351 + check(exp_attr1 == 100, "Wrong attr value");
1.352 + check(exp_attr2 == 100, "Wrong attr value");
1.353 +}
1.354 +
1.355 +void checkGraphReaderWriter() {
1.356 + typedef lemon::SmartGraph Graph;
1.357 + Graph graph;
1.358 + Graph::Node n1 = graph.addNode();
1.359 + Graph::Node n2 = graph.addNode();
1.360 + Graph::Node n3 = graph.addNode();
1.361 +
1.362 + Graph::Edge e1 = graph.addEdge(n1, n2);
1.363 + Graph::Edge e2 = graph.addEdge(n2, n3);
1.364 +
1.365 + Graph::NodeMap<int> node_map(graph);
1.366 + node_map[n1] = 11;
1.367 + node_map[n2] = 12;
1.368 + node_map[n3] = 13;
1.369 +
1.370 + Graph::EdgeMap<int> edge_map(graph);
1.371 + edge_map[e1] = 21;
1.372 + edge_map[e2] = 22;
1.373 +
1.374 + Graph::ArcMap<int> arc_map(graph);
1.375 + arc_map[graph.direct(e1, true)] = 211;
1.376 + arc_map[graph.direct(e1, false)] = 212;
1.377 + arc_map[graph.direct(e2, true)] = 221;
1.378 + arc_map[graph.direct(e2, false)] = 222;
1.379 +
1.380 + int attr = 100;
1.381 +
1.382 + std::ostringstream os;
1.383 + lemon::GraphWriter<Graph> writer(graph, os);
1.384 +
1.385 + writer.nodeMap("node_map1", node_map);
1.386 + writer.nodeMap("node_map2", node_map, WriterConverter());
1.387 + writer.edgeMap("edge_map1", edge_map);
1.388 + writer.edgeMap("edge_map2", edge_map, WriterConverter());
1.389 + writer.arcMap("arc_map1", arc_map);
1.390 + writer.arcMap("arc_map2", arc_map, WriterConverter());
1.391 + writer.node("node", n2);
1.392 + writer.edge("edge", e1);
1.393 + writer.arc("arc", graph.direct(e1, false));
1.394 + writer.attribute("attr1", attr);
1.395 + writer.attribute("attr2", attr, WriterConverter());
1.396 +
1.397 + writer.run();
1.398 +
1.399 + typedef lemon::ListGraph ExpGraph;
1.400 + ExpGraph exp_graph;
1.401 + ExpGraph::NodeMap<int> exp_node_map1(exp_graph);
1.402 + ExpGraph::NodeMap<int> exp_node_map2(exp_graph);
1.403 + ExpGraph::EdgeMap<int> exp_edge_map1(exp_graph);
1.404 + ExpGraph::EdgeMap<int> exp_edge_map2(exp_graph);
1.405 + ExpGraph::ArcMap<int> exp_arc_map1(exp_graph);
1.406 + ExpGraph::ArcMap<int> exp_arc_map2(exp_graph);
1.407 + ExpGraph::Node exp_n2;
1.408 + ExpGraph::Edge exp_e1;
1.409 + ExpGraph::Arc exp_a1;
1.410 + int exp_attr1;
1.411 + int exp_attr2;
1.412 +
1.413 + std::istringstream is(os.str());
1.414 + lemon::GraphReader<ExpGraph> reader(exp_graph, is);
1.415 +
1.416 + reader.nodeMap("node_map1", exp_node_map1);
1.417 + reader.nodeMap("node_map2", exp_node_map2, ReaderConverter());
1.418 + reader.edgeMap("edge_map1", exp_edge_map1);
1.419 + reader.edgeMap("edge_map2", exp_edge_map2, ReaderConverter());
1.420 + reader.arcMap("arc_map1", exp_arc_map1);
1.421 + reader.arcMap("arc_map2", exp_arc_map2, ReaderConverter());
1.422 + reader.node("node", exp_n2);
1.423 + reader.edge("edge", exp_e1);
1.424 + reader.arc("arc", exp_a1);
1.425 + reader.attribute("attr1", exp_attr1);
1.426 + reader.attribute("attr2", exp_attr2, ReaderConverter());
1.427 +
1.428 + reader.run();
1.429 +
1.430 + check(lemon::countNodes(exp_graph) == 3, "Wrong number of nodes");
1.431 + check(lemon::countEdges(exp_graph) == 2, "Wrong number of edges");
1.432 + check(lemon::countArcs(exp_graph) == 4, "Wrong number of arcs");
1.433 + check(exp_node_map1[exp_n2] == 12, "Wrong map value");
1.434 + check(exp_node_map2[exp_n2] == 12, "Wrong map value");
1.435 + check(exp_edge_map1[exp_e1] == 21, "Wrong map value");
1.436 + check(exp_edge_map2[exp_e1] == 21, "Wrong map value");
1.437 + check(exp_arc_map1[exp_a1] == 212, "Wrong map value");
1.438 + check(exp_arc_map2[exp_a1] == 212, "Wrong map value");
1.439 + check(exp_attr1 == 100, "Wrong attr value");
1.440 + check(exp_attr2 == 100, "Wrong attr value");
1.441 +}
1.442 +
1.443 +void checkBpGraphReaderWriter() {
1.444 + typedef lemon::SmartBpGraph Graph;
1.445 + Graph graph;
1.446 + Graph::RedNode rn1 = graph.addRedNode();
1.447 + Graph::RedNode rn2 = graph.addRedNode();
1.448 + Graph::RedNode rn3 = graph.addRedNode();
1.449 + Graph::BlueNode bn1 = graph.addBlueNode();
1.450 + Graph::BlueNode bn2 = graph.addBlueNode();
1.451 + Graph::Node n = bn1;
1.452 +
1.453 + Graph::Edge e1 = graph.addEdge(rn1, bn1);
1.454 + Graph::Edge e2 = graph.addEdge(rn2, bn1);
1.455 +
1.456 + Graph::NodeMap<int> node_map(graph);
1.457 + node_map[rn1] = 11;
1.458 + node_map[rn2] = 12;
1.459 + node_map[rn3] = 13;
1.460 + node_map[bn1] = 14;
1.461 + node_map[bn2] = 15;
1.462 +
1.463 + Graph::NodeMap<int> red_node_map(graph);
1.464 + red_node_map[rn1] = 411;
1.465 + red_node_map[rn2] = 412;
1.466 + red_node_map[rn3] = 413;
1.467 +
1.468 + Graph::NodeMap<int> blue_node_map(graph);
1.469 + blue_node_map[bn1] = 414;
1.470 + blue_node_map[bn2] = 415;
1.471 +
1.472 + Graph::EdgeMap<int> edge_map(graph);
1.473 + edge_map[e1] = 21;
1.474 + edge_map[e2] = 22;
1.475 +
1.476 + Graph::ArcMap<int> arc_map(graph);
1.477 + arc_map[graph.direct(e1, true)] = 211;
1.478 + arc_map[graph.direct(e1, false)] = 212;
1.479 + arc_map[graph.direct(e2, true)] = 221;
1.480 + arc_map[graph.direct(e2, false)] = 222;
1.481 +
1.482 + int attr = 100;
1.483 +
1.484 + std::ostringstream os;
1.485 + lemon::BpGraphWriter<Graph> writer(graph, os);
1.486 +
1.487 + writer.nodeMap("node_map1", node_map);
1.488 + writer.nodeMap("node_map2", node_map, WriterConverter());
1.489 + writer.nodeMap("red_node_map1", red_node_map);
1.490 + writer.nodeMap("red_node_map2", red_node_map, WriterConverter());
1.491 + writer.nodeMap("blue_node_map1", blue_node_map);
1.492 + writer.nodeMap("blue_node_map2", blue_node_map, WriterConverter());
1.493 + writer.edgeMap("edge_map1", edge_map);
1.494 + writer.edgeMap("edge_map2", edge_map, WriterConverter());
1.495 + writer.arcMap("arc_map1", arc_map);
1.496 + writer.arcMap("arc_map2", arc_map, WriterConverter());
1.497 + writer.node("node", n);
1.498 + writer.redNode("red_node", rn1);
1.499 + writer.blueNode("blue_node", bn2);
1.500 + writer.edge("edge", e1);
1.501 + writer.arc("arc", graph.direct(e1, false));
1.502 + writer.attribute("attr1", attr);
1.503 + writer.attribute("attr2", attr, WriterConverter());
1.504 +
1.505 + writer.run();
1.506 +
1.507 + typedef lemon::ListBpGraph ExpGraph;
1.508 + ExpGraph exp_graph;
1.509 + ExpGraph::NodeMap<int> exp_node_map1(exp_graph);
1.510 + ExpGraph::NodeMap<int> exp_node_map2(exp_graph);
1.511 + ExpGraph::RedNodeMap<int> exp_red_node_map1(exp_graph);
1.512 + ExpGraph::RedNodeMap<int> exp_red_node_map2(exp_graph);
1.513 + ExpGraph::BlueNodeMap<int> exp_blue_node_map1(exp_graph);
1.514 + ExpGraph::BlueNodeMap<int> exp_blue_node_map2(exp_graph);
1.515 + ExpGraph::EdgeMap<int> exp_edge_map1(exp_graph);
1.516 + ExpGraph::EdgeMap<int> exp_edge_map2(exp_graph);
1.517 + ExpGraph::ArcMap<int> exp_arc_map1(exp_graph);
1.518 + ExpGraph::ArcMap<int> exp_arc_map2(exp_graph);
1.519 + ExpGraph::Node exp_n;
1.520 + ExpGraph::RedNode exp_rn1;
1.521 + ExpGraph::BlueNode exp_bn2;
1.522 + ExpGraph::Edge exp_e1;
1.523 + ExpGraph::Arc exp_a1;
1.524 + int exp_attr1;
1.525 + int exp_attr2;
1.526 +
1.527 + std::istringstream is(os.str());
1.528 + lemon::BpGraphReader<ExpGraph> reader(exp_graph, is);
1.529 +
1.530 + reader.nodeMap("node_map1", exp_node_map1);
1.531 + reader.nodeMap("node_map2", exp_node_map2, ReaderConverter());
1.532 + reader.redNodeMap("red_node_map1", exp_red_node_map1);
1.533 + reader.redNodeMap("red_node_map2", exp_red_node_map2, ReaderConverter());
1.534 + reader.blueNodeMap("blue_node_map1", exp_blue_node_map1);
1.535 + reader.blueNodeMap("blue_node_map2", exp_blue_node_map2, ReaderConverter());
1.536 + reader.edgeMap("edge_map1", exp_edge_map1);
1.537 + reader.edgeMap("edge_map2", exp_edge_map2, ReaderConverter());
1.538 + reader.arcMap("arc_map1", exp_arc_map1);
1.539 + reader.arcMap("arc_map2", exp_arc_map2, ReaderConverter());
1.540 + reader.node("node", exp_n);
1.541 + reader.redNode("red_node", exp_rn1);
1.542 + reader.blueNode("blue_node", exp_bn2);
1.543 + reader.edge("edge", exp_e1);
1.544 + reader.arc("arc", exp_a1);
1.545 + reader.attribute("attr1", exp_attr1);
1.546 + reader.attribute("attr2", exp_attr2, ReaderConverter());
1.547 +
1.548 + reader.run();
1.549 +
1.550 + check(lemon::countNodes(exp_graph) == 5, "Wrong number of nodes");
1.551 + check(lemon::countRedNodes(exp_graph) == 3, "Wrong number of red nodes");
1.552 + check(lemon::countBlueNodes(exp_graph) == 2, "Wrong number of blue nodes");
1.553 + check(lemon::countEdges(exp_graph) == 2, "Wrong number of edges");
1.554 + check(lemon::countArcs(exp_graph) == 4, "Wrong number of arcs");
1.555 + check(exp_node_map1[exp_n] == 14, "Wrong map value");
1.556 + check(exp_node_map2[exp_n] == 14, "Wrong map value");
1.557 + check(exp_red_node_map1[exp_rn1] == 411, "Wrong map value");
1.558 + check(exp_red_node_map2[exp_rn1] == 411, "Wrong map value");
1.559 + check(exp_blue_node_map1[exp_bn2] == 415, "Wrong map value");
1.560 + check(exp_blue_node_map2[exp_bn2] == 415, "Wrong map value");
1.561 + check(exp_edge_map1[exp_e1] == 21, "Wrong map value");
1.562 + check(exp_edge_map2[exp_e1] == 21, "Wrong map value");
1.563 + check(exp_arc_map1[exp_a1] == 212, "Wrong map value");
1.564 + check(exp_arc_map2[exp_a1] == 212, "Wrong map value");
1.565 + check(exp_attr1 == 100, "Wrong attr value");
1.566 + check(exp_attr2 == 100, "Wrong attr value");
1.567 +}
1.568 +
1.569 +
1.570 +int main() {
1.571 + { // Check digrpah
1.572 + checkDigraphReaderWriter();
1.573 + }
1.574 + { // Check graph
1.575 + checkGraphReaderWriter();
1.576 + }
1.577 + { // Check bipartite graph
1.578 + checkBpGraphReaderWriter();
1.579 + }
1.580 + return 0;
1.581 +}