@@ -79,13 +79,13 @@ def test_feed_empty_data(self):
79
79
stream = asyncio .StreamReader (loop = self .loop )
80
80
81
81
stream .feed_data (b'' )
82
- self .assertEqual (0 , stream ._byte_count )
82
+ self .assertEqual (b'' , stream ._buffer )
83
83
84
- def test_feed_data_byte_count (self ):
84
+ def test_feed_nonempty_data (self ):
85
85
stream = asyncio .StreamReader (loop = self .loop )
86
86
87
87
stream .feed_data (self .DATA )
88
- self .assertEqual (len ( self .DATA ) , stream ._byte_count )
88
+ self .assertEqual (self .DATA , stream ._buffer )
89
89
90
90
def test_read_zero (self ):
91
91
# Read zero bytes.
@@ -94,7 +94,7 @@ def test_read_zero(self):
94
94
95
95
data = self .loop .run_until_complete (stream .read (0 ))
96
96
self .assertEqual (b'' , data )
97
- self .assertEqual (len ( self .DATA ) , stream ._byte_count )
97
+ self .assertEqual (self .DATA , stream ._buffer )
98
98
99
99
def test_read (self ):
100
100
# Read bytes.
@@ -107,7 +107,7 @@ def cb():
107
107
108
108
data = self .loop .run_until_complete (read_task )
109
109
self.assertEqual (self .DATA , data )
110
- self .assertFalse ( stream ._byte_count )
110
+ self .assertEqual ( b'' , stream ._buffer )
111
111
112
112
def test_read_line_breaks (self ):
113
113
# Read bytes without line breaks.
@@ -118,7 +118,7 @@ def test_read_line_breaks(self):
118
118
data = self .loop .run_until_complete (stream .read (5 ))
119
119
120
120
self .assertEqual (b'line1' , data )
121
- self .assertEqual (5 , stream ._byte_count )
121
+ self .assertEqual (b'line2' , stream ._buffer )
122
122
123
123
def test_read_eof (self ):
124
124
# Read bytes, stop at eof.
@@ -131,7 +131,7 @@ def cb():
131
131
132
132
data = self .loop .run_until_complete (read_task )
133
133
self .assertEqual (b'' , data )
134
- self .assertFalse ( stream ._byte_count )
134
+ self .assertEqual ( b'' , stream ._buffer )
135
135
136
136
def test_read_until_eof (self ):
137
137
# Read all bytes until eof.
@@ -147,7 +147,7 @@ def cb():
147
147
data = self .loop .run_until_complete (read_task )
148
148
149
149
self .assertEqual (b'chunk1\n chunk2' , data )
150
- self .assertFalse ( stream ._byte_count )
150
+ self .assertEqual ( b'' , stream ._buffer )
151
151
152
152
def test_read_exception (self ):
153
153
stream = asyncio .StreamReader (loop = self .loop )
@@ -161,7 +161,8 @@ def test_read_exception(self):
161
161
ValueError , self .loop .run_until_complete , stream .read (2 ))
162
162
163
163
def test_readline (self ):
164
- # Read one line.
164
+ # Read one line. 'readline' will need to wait for the data
165
+ # to come from 'cb'
165
166
stream = asyncio .StreamReader (loop = self .loop )
166
167
stream .feed_data (b'chunk1 ' )
167
168
read_task = asyncio .Task (stream .readline (), loop = self .loop )
@@ -174,30 +175,40 @@ def cb():
174
175
175
176
line = self .loop .run_until_complete (read_task )
176
177
self .assertEqual (b'chunk1 chunk2 chunk3 \n ' , line )
177
- self .assertEqual (len ( b' \n chunk4') - 1 , stream ._byte_count )
F438
178
+ self .assertEqual (b' chunk4' , stream ._buffer )
178
179
179
180
def test_readline_limit_with_existing_data (self ):
180
- stream = asyncio .StreamReader (3 , loop = self .loop )
181
+ # Read one line. The data is in StreamReader's buffer
182
+ # before the event loop is run.
183
+
184
+ stream = asyncio .StreamReader (limit = 3 , loop = self .loop )
181
185
stream .feed_data (b'li' )
182
186
stream .feed_data (b'ne1\n line2\n ' )
183
187
184
188
self .assertRaises (
185
189
ValueError , self .loop .run_until_complete , stream .readline ())
186
- self .assertEqual ([b'line2\n ' ], list (stream ._buffer ))
190
+ # The buffer should contain the remaining data after exception
191
+ self .assertEqual (b'line2\n ' , stream ._buffer )
187
192
188
- stream = asyncio .StreamReader (3 , loop = self .loop )
193
+ stream = asyncio .StreamReader (limit = 3 , loop = self .loop )
189
194
stream .feed_data (b'li' )
190
195
stream .feed_data (b'ne1' )
191
196
stream .feed_data (b'li' )
192
197
193
198
self .assertRaises (
194
199
ValueError , self .loop .run_until_complete , stream .readline ())
195
- self .assertEqual ([b'li' ], list (stream ._buffer ))
196
- self .assertEqual (2 , stream ._byte_count )
200
+ # No b'\n' at the end. The 'limit' is set to 3. So before
201
+ # waiting for the new data in buffer, 'readline' will consume
202
+ # the entire buffer, and since the length of the consumed data
203
+ # is more than 3, it will raise a ValudError. The buffer is
204
+ # expected to be empty now.
205
+ self .assertEqual (b'' , stream ._buffer )
197
206
198
207
def test_readline_limit (self ):
199
- stream = asyncio .StreamReader (7 , loop = self .loop )
208
+ # Read one line. StreamReaders are fed with data after
209
+ # their 'readline' methods are called.
200
210
211
+ stream = asyncio .StreamReader (limit = 7 , loop = self .loop )
201
212
def cb ():
202
213
stream .feed_data (b'chunk1' )
203
214
stream .feed_data (b'chunk2' )
@@ -207,18 +218,33 @@ def cb():
207
218
208
219
self .assertRaises (
209
220
ValueError , self .loop .run_until_complete , stream .readline ())
210
- self .assertEqual ([b'chunk3\n ' ], list (stream ._buffer ))
211
- self .assertEqual (7 , stream ._byte_count )
221
+ # The buffer had just one line of data, and after raising
222
+ # a ValueError it should be empty.
223
+ self .assertEqual (b'' , stream ._buffer )
224
+
225
+ stream = asyncio .StreamReader (limit = 7 , loop = self .loop )
226
+ def cb ():
227
+ stream .feed_data (b'chunk1' )
228
+ stream .feed_data (b'chunk2\n ' )
229
+ stream .feed_data (b'chunk3\n ' )
230
+ stream .feed_eof ()
231
+ self .loop .call_soon (cb )
232
+
233
+ self .assertRaises (
234
+ ValueError , self .loop .run_until_complete , stream .readline ())
235
+ self .assertEqual (b'chunk3\n ' , stream ._buffer )
212
236
213
- def test_readline_line_byte_count (self ):
237
+ def test_readline_nolimit_nowait (self ):
238
+ # All needed data for the first 'readline' call will be
239
+ # in the buffer.
214
240
stream = asyncio .StreamReader (loop = self .loop )
215
241
stream .feed_data (self .DATA [:6 ])
216
242
stream .feed_data (self .DATA [6 :])
217
243
218
244
line = self .loop .run_until_complete (stream .readline ())
219
245
220
246
self .assertEqual (b'line1\n ' , line )
221
- self .assertEqual (len ( self . DATA ) - len ( b'line1 \n ' ) , stream ._byte_count )
247
+ self .assertEqual (b'line2 \n line3 \n ' , stream ._buffer )
222
248
223
249
def test_readline_eof (self ):
224
250
stream = asyncio .StreamReader (loop = self .loop )
@@ -244,9 +270,7 @@ def test_readline_read_byte_count(self):
244
270
data = self .loop .run_until_complete (stream .read (7 ))
245
271
246
272
self .assertEqual (b'line2\n l' , data )
247
- self .assertEqual (
248
- len (self .DATA ) - len (b'line1\n ' ) - len (b'line2\n l' ),
249
- stream ._byte_count )
273
+ self .assertEqual (b'ine3\n ' , stream ._buffer )
250
274
251
275
def test_readline_exception (self ):
252
276
stream = asyncio .StreamReader (loop = self .loop )
@@ -258,6 +282,7 @@ def test_readline_exception(self):
258
282
stream .set_exception (ValueError ())
259
283
self .assertRaises (
260
284
ValueError , self .loop .run_until_complete , stream .readline ())
285
+ self .assertEqual (b'' , stream ._buffer )
261
286
262
287
def test_readexactly_zero_or_less (self ):
263
288
# Read exact number of bytes (zero or less).
@@ -266,11 +291,11 @@ def test_readexactly_zero_or_less(self):
266
291
267
292
data = self .loop .run_until_complete (stream .readexactly (0 ))
268
293
self .assertEqual (b'' , data )
269
- self .assertEqual (len ( self .DATA ) , stream ._byte_count )
294
+ self .assertEqual (self .DATA , stream ._buffer )
270
295
271
296
data = self .loop .run_until_complete (stream .readexactly (- 1 ))
272
297
self .assertEqual (b'' , data )
273
- self .assertEqual (len ( self .DATA ) , stream ._byte_count )
298
+ self .assertEqual (self .DATA , stream ._buffer )
274
299
275
300
def test_readexactly (self ):
276
301
# Read exact number of bytes.
@@ -287,7 +312,7 @@ def cb():
287
312
288
313
data = self .loop .run_until_complete (read_task )
289
314
self .assertEqual (self .DATA + self .DATA , data )
290
- self .assertEqual (len ( self .DATA ) , stream ._byte_count )
315
+ self .assertEqual (self .DATA , stream ._buffer )
291
316
292
317
def test_readexactly_eof (self ):
293
318
# Read exact number of bytes (eof).
@@ -306,7 +331,7 @@ def cb():
306
331
self .assertEqual (cm .exception .expected , n )
307
332
self .assertEqual (str (cm .exception ),
308
333
'18 bytes read on a total of 36 expected bytes' )
309
- self .assertFalse ( stream ._byte_count )
334
+ self .assertEqual ( b'' , stream ._buffer )
310
335
311
336
def test_readexactly_exception (self ):
312
337
stream = asyncio .StreamReader (loop = self .loop )
0 commit comments