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(t: vector_source(src)); |
70 | second.open(t: 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(t: 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(t: 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(t: 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 | } |
173 | |