]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com) |
2 | // (C) Copyright 2004-2007 Jonathan Turkanis | |
3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying | |
4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt.) | |
5 | ||
6 | // See http://www.boost.org/libs/iostreams for documentation. | |
7 | ||
8 | #include <algorithm> // Equal | |
9 | #include <vector> | |
10 | #include <boost/config.hpp> // MSVC. | |
11 | #include <boost/detail/workaround.hpp> | |
12 | #include <boost/iostreams/concepts.hpp> // sink | |
13 | #include <boost/iostreams/copy.hpp> | |
14 | #include <boost/iostreams/device/array.hpp> | |
15 | #include <boost/iostreams/device/file.hpp> | |
16 | #include <boost/iostreams/stream.hpp> | |
17 | #include <boost/test/test_tools.hpp> | |
18 | #include <boost/test/unit_test.hpp> | |
19 | #include "../example/container_device.hpp" | |
20 | #include "detail/sequence.hpp" | |
21 | ||
22 | using namespace std; | |
23 | using namespace boost; | |
24 | using namespace boost::iostreams; | |
25 | using namespace boost::iostreams::example; | |
26 | using namespace boost::iostreams::test; | |
27 | using boost::unit_test::test_suite; | |
28 | ||
29 | //------------------Definition of fixed_sink----------------------------------// | |
30 | ||
31 | /*class fixed_sink : public sink { | |
32 | public: | |
33 | fixed_sink(vector<char>& storage) | |
34 | : storage_(storage), pos_(0) | |
35 | { } | |
36 | std::streamsize write(const char_type* s, std::streamsize n) | |
37 | { | |
38 | streamsize capacity = static_cast<streamsize>(storage_.size() - pos_); | |
39 | streamsize result = (min)(n, capacity); | |
40 | std::copy(s, s + result, storage_.begin() + pos_); | |
41 | pos_ += result; | |
42 | return result; | |
43 | } | |
44 | private: | |
45 | fixed_sink operator=(const fixed_sink&); | |
46 | typedef vector<char>::size_type size_type; | |
47 | vector<char>& storage_; | |
48 | size_type pos_; | |
49 | };*/ | |
50 | ||
51 | //------------------Definition of stream types--------------------------------// | |
52 | ||
53 | typedef container_source< vector<char> > vector_source; | |
54 | typedef container_sink< vector<char> > vector_sink; | |
55 | typedef stream<vector_source> vector_istream; | |
56 | typedef stream<vector_sink> vector_ostream; | |
57 | //typedef stream<fixed_sink> fixed_ostream; | |
58 | ||
59 | //------------------Definition of copy_test-----------------------------------// | |
60 | ||
61 | void copy_test() | |
62 | { | |
63 | // Stream to stream | |
64 | { | |
65 | test_sequence<> src; | |
66 | vector<char> dest; | |
67 | vector_istream first; | |
68 | vector_ostream second; | |
69 | first.open(vector_source(src)); | |
70 | second.open(vector_sink(dest)); | |
71 | BOOST_CHECK_MESSAGE( | |
72 | boost::iostreams::copy(first, second) == | |
73 | static_cast<streamsize>(src.size()) && | |
74 | src == dest, | |
75 | "failed copying from stream to stream" | |
76 | ); | |
77 | } | |
78 | ||
79 | // Stream to indirect sink | |
80 | { | |
81 | test_sequence<> src; | |
82 | vector<char> dest; | |
83 | vector_istream in; | |
84 | vector_sink out(dest); | |
85 | in.open(vector_source(src)); | |
86 | BOOST_CHECK_MESSAGE( | |
87 | boost::iostreams::copy(in, out) == | |
88 | static_cast<streamsize>(src.size()) && | |
89 | src == dest, | |
90 | "failed copying from stream to indirect sink" | |
91 | ); | |
92 | } | |
93 | ||
94 | // Indirect source to stream | |
95 | { | |
96 | test_sequence<> src; | |
97 | vector<char> dest; | |
98 | vector_source in(src); | |
99 | vector_ostream out; | |
100 | out.open(vector_sink(dest)); | |
101 | BOOST_CHECK_MESSAGE( | |
102 | boost::iostreams::copy(in, out) == | |
103 | static_cast<streamsize>(src.size()) && | |
104 | src == dest, | |
105 | "failed copying from indirect source to stream" | |
106 | ); | |
107 | } | |
108 | ||
109 | // Indirect source to indirect sink | |
110 | { | |
111 | test_sequence<> src; | |
112 | vector<char> dest; | |
113 | vector_source in(src); | |
114 | vector_sink out(dest); | |
115 | BOOST_CHECK_MESSAGE( | |
116 | boost::iostreams::copy(in, out) == | |
117 | static_cast<streamsize>(src.size()) && | |
118 | src == dest, | |
119 | "failed copying from indirect source to indirect sink" | |
120 | ); | |
121 | } | |
122 | ||
123 | // Direct source to direct sink | |
124 | { | |
125 | test_sequence<> src; | |
126 | vector<char> dest(src.size(), '?'); | |
127 | array_source in(&src[0], &src[0] + src.size()); | |
128 | array_sink out(&dest[0], &dest[0] + dest.size()); | |
129 | BOOST_CHECK_MESSAGE( | |
130 | boost::iostreams::copy(in, out) == | |
131 | static_cast<streamsize>(src.size()) && | |
132 | src == dest, | |
133 | "failed copying from direct source to direct sink" | |
134 | ); | |
135 | } | |
136 | ||
137 | // Direct source to indirect sink | |
138 | { | |
139 | test_sequence<> src; | |
140 | vector<char> dest; | |
141 | array_source in(&src[0], &src[0] + src.size()); | |
142 | vector_ostream out(dest); | |
143 | BOOST_CHECK_MESSAGE( | |
144 | boost::iostreams::copy(in, out) == | |
145 | static_cast<streamsize>(src.size()) && | |
146 | src == dest, | |
147 | "failed copying from direct source to indirect sink" | |
148 | ); | |
149 | } | |
150 | ||
151 | // Indirect source to direct sink | |
152 | { | |
153 | test_sequence<> src; | |
154 | vector<char> dest(src.size(), '?'); | |
155 | vector_istream in; | |
156 | array_sink out(&dest[0], &dest[0] + dest.size()); | |
157 | in.open(vector_source(src)); | |
158 | BOOST_CHECK_MESSAGE( | |
159 | boost::iostreams::copy(in, out) == | |
160 | static_cast<streamsize>(src.size()) && | |
161 | src == dest, | |
162 | "failed copying from indirect source to direct sink" | |
163 | ); | |
164 | } | |
165 | } | |
166 | ||
167 | test_suite* init_unit_test_suite(int, char* []) | |
168 | { | |
169 | test_suite* test = BOOST_TEST_SUITE("copy test"); | |
170 | test->add(BOOST_TEST_CASE(©_test)); | |
171 | return test; | |
172 | } |