1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
// (C) Copyright 2009 Andrew Sutton
//
// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0 (See accompanying file
// LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
#ifndef TEST_PROPERTIES_HPP
#define TEST_PROPERTIES_HPP
#include <boost/concept/assert.hpp>
template<typename T> T const& as_const(T& x) { return x; }
template<typename T> void ignore(T const&) { }
template<typename Graph>
void test_graph_bundle(Graph& g, boost::mpl::true_) {
using namespace boost;
std::cout << "...test_graph_bundle\n";
GraphBundle& b1 = g[graph_bundle];
GraphBundle& b2 = get_property(g);
ignore(b1); ignore(b2);
GraphBundle const& cb1 = ::as_const(g)[graph_bundle];
GraphBundle const& cb2 = get_property(g);
ignore(cb1); ignore(cb2);
}
template<typename Graph>
void test_graph_bundle(Graph& g, boost::mpl::false_)
{ }
/** @name Test Vertex Bundle
* Exercise the vertex bundle. Note that this is expected to be of type
* VertexBundle.
*/
//@{
template <typename Graph, typename VertexSet>
void test_vertex_bundle(Graph& g, VertexSet const& verts, boost::mpl::true_) {
using namespace boost;
BOOST_CONCEPT_ASSERT((GraphConcept<Graph>));
typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
BOOST_CONCEPT_ASSERT((PropertyGraphConcept<Graph, Vertex, vertex_bundle_t>));
// Test bundling via the graph object on the lollipop vertex.
Vertex v = verts[5];
VertexBundle& b = g[v];
b.value = 10;
BOOST_ASSERT(g[v].value == 10);
// Test bundling via the property map.
typedef typename property_map<Graph, int VertexBundle::*>::type BundleMap;
BOOST_CONCEPT_ASSERT((ReadWritePropertyMapConcept<BundleMap, Vertex>));
BundleMap map = get(&VertexBundle::value, g);
put(map, v, 5);
BOOST_ASSERT(get(map, v) == 5);
typedef typename property_map<Graph, int VertexBundle::*>::const_type ConstBundleMap;
BOOST_CONCEPT_ASSERT((ReadablePropertyMapConcept<ConstBundleMap, Vertex>));
ConstBundleMap cmap = get(&VertexBundle::value, (Graph const&)g);
BOOST_ASSERT(get(cmap, v) == 5);
}
template <typename Graph, typename VertexSet>
void test_vertex_bundle(Graph&, VertexSet const&, boost::mpl::false_)
{ }
//@}
/** @name Test Edge Bundle
* Exercise the edge bundle. Note that this is expected to be of type
* EdgeBundle.
*/
//@{
template <typename Graph, typename VertexSet>
void test_edge_bundle(Graph& g, VertexSet const& verts, boost::mpl::true_) {
using namespace boost;
BOOST_CONCEPT_ASSERT((GraphConcept<Graph>));
typedef typename boost::graph_traits<Graph>::edge_descriptor Edge;
BOOST_CONCEPT_ASSERT((PropertyGraphConcept<Graph, Edge, edge_bundle_t>));
std::cout << "...test_edge_bundle\n";
// Test bundling via the graph object on the lollipop edge.
Edge e = boost::edge(verts[5], verts[3], g).first;
EdgeBundle& b = g[e];
b.value = 10;
BOOST_ASSERT(g[e].value == 10);
// Test bundling via the property map.
typedef typename boost::property_map<Graph, int EdgeBundle::*>::type BundleMap;
BOOST_CONCEPT_ASSERT((ReadWritePropertyMapConcept<BundleMap, Edge>));
BundleMap map = get(&EdgeBundle::value, g);
put(map, e, 5);
BOOST_ASSERT(get(map, e) == 5);
typedef typename boost::property_map<Graph, int EdgeBundle::*>::const_type ConstBundleMap;
BOOST_CONCEPT_ASSERT((ReadablePropertyMapConcept<BundleMap, Edge>));
ConstBundleMap cmap = get(&EdgeBundle::value, (Graph const&)g);
BOOST_ASSERT(get(cmap, e) == 5);
}
template <typename Graph, typename VertexSet>
void test_edge_bundle(Graph&, VertexSet const&, boost::mpl::false_)
{ }
//@}
/**
* Test the properties of a graph. Basically, we expect these to be one of
* bundled or not. This test could also be expanded to test non-bundled
* properties. This just bootstraps the tests.
*/
template <typename Graph, typename VertexSet>
void test_properties(Graph& g, VertexSet const& verts) {
using namespace boost;
typename has_bundled_graph_property<Graph>::type graph_bundled;
typename has_bundled_vertex_property<Graph>::type vertex_bundled;
typename has_bundled_edge_property<Graph>::type edge_bundled;
test_graph_bundle(g, graph_bundled);
test_vertex_bundle(g, verts, vertex_bundled);
test_edge_bundle(g, verts, edge_bundled);
}
//@}
#endif
|
