diff --git a/quiche/src/lib.rs b/quiche/src/lib.rs
index b122853..58676f3 100644
--- a/quiche/src/lib.rs
+++ b/quiche/src/lib.rs
@@ -11059,11 +11059,7 @@
         assert_eq!(r.next(), Some(0));
         assert_eq!(r.next(), None);
 
-        loop {
-            if pipe.server.stream_send(0, b"world", false) == Err(Error::Done) {
-                break;
-            }
-
+        while pipe.server.stream_send(0, b"world", false) != Err(Error::Done) {
             assert_eq!(pipe.advance(), Ok(()));
         }
 
@@ -12117,6 +12113,157 @@
     }
 
     #[test]
+    fn stop_sending_before_flushed_packets() {
+        let mut b = [0; 15];
+
+        let mut buf = [0; 65535];
+
+        let mut pipe = testing::Pipe::new().unwrap();
+        assert_eq!(pipe.handshake(), Ok(()));
+
+        // Client sends some data, and closes stream.
+        assert_eq!(pipe.client.stream_send(0, b"hello", true), Ok(5));
+        assert_eq!(pipe.advance(), Ok(()));
+
+        // Server gets data.
+        let mut r = pipe.server.readable();
+        assert_eq!(r.next(), Some(0));
+        assert_eq!(r.next(), None);
+
+        assert_eq!(pipe.server.stream_recv(0, &mut b), Ok((5, true)));
+        assert!(pipe.server.stream_finished(0));
+
+        let mut r = pipe.server.readable();
+        assert_eq!(r.next(), None);
+
+        // Server sends data, until blocked.
+        let mut r = pipe.server.writable();
+        assert_eq!(r.next(), Some(0));
+        assert_eq!(r.next(), None);
+
+        while pipe.server.stream_send(0, b"world", false) != Err(Error::Done) {}
+
+        let mut r = pipe.server.writable();
+        assert_eq!(r.next(), None);
+
+        // Client sends STOP_SENDING.
+        let frames = [frame::Frame::StopSending {
+            stream_id: 0,
+            error_code: 42,
+        }];
+
+        let pkt_type = packet::Type::Short;
+        let len = pipe
+            .send_pkt_to_server(pkt_type, &frames, &mut buf)
+            .unwrap();
+
+        // Server sent a RESET_STREAM frame in response.
+        let frames =
+            testing::decode_pkt(&mut pipe.client, &mut buf[..len]).unwrap();
+
+        let mut iter = frames.iter();
+
+        // Skip ACK frame.
+        iter.next();
+
+        assert_eq!(
+            iter.next(),
+            Some(&frame::Frame::ResetStream {
+                stream_id: 0,
+                error_code: 42,
+                final_size: 0,
+            })
+        );
+
+        // Stream is writable, but writing returns an error.
+        let mut r = pipe.server.writable();
+        assert_eq!(r.next(), Some(0));
+        assert_eq!(r.next(), None);
+
+        assert_eq!(
+            pipe.server.stream_send(0, b"world", true),
+            Err(Error::StreamStopped(42)),
+        );
+
+        assert_eq!(pipe.server.streams.len(), 1);
+
+        // Client acks RESET_STREAM frame.
+        let mut ranges = ranges::RangeSet::default();
+        ranges.insert(0..6);
+
+        let frames = [frame::Frame::ACK {
+            ack_delay: 15,
+            ranges,
+            ecn_counts: None,
+        }];
+
+        assert_eq!(pipe.send_pkt_to_server(pkt_type, &frames, &mut buf), Ok(0));
+
+        // Client has ACK'd the RESET_STREAM so the stream is collected.
+        assert_eq!(pipe.server.streams.len(), 0);
+    }
+
+    #[test]
+    fn reset_before_flushed_packets() {
+        let mut b = [0; 15];
+
+        let mut config = Config::new(crate::PROTOCOL_VERSION).unwrap();
+        config
+            .load_cert_chain_from_pem_file("examples/cert.crt")
+            .unwrap();
+        config
+            .load_priv_key_from_pem_file("examples/cert.key")
+            .unwrap();
+        config
+            .set_application_protos(&[b"proto1", b"proto2"])
+            .unwrap();
+        config.set_initial_max_data(30);
+        config.set_initial_max_stream_data_bidi_local(5);
+        config.set_initial_max_stream_data_bidi_remote(15);
+        config.set_initial_max_streams_bidi(3);
+        config.verify_peer(false);
+
+        let mut pipe = testing::Pipe::with_config(&mut config).unwrap();
+        assert_eq!(pipe.handshake(), Ok(()));
+
+        // Client sends some data, and closes stream.
+        assert_eq!(pipe.client.stream_send(0, b"hello", true), Ok(5));
+        assert_eq!(pipe.advance(), Ok(()));
+
+        // Server gets data.
+        let mut r = pipe.server.readable();
+        assert_eq!(r.next(), Some(0));
+        assert_eq!(r.next(), None);
+
+        assert_eq!(pipe.server.stream_recv(0, &mut b), Ok((5, true)));
+        assert!(pipe.server.stream_finished(0));
+
+        let mut r = pipe.server.readable();
+        assert_eq!(r.next(), None);
+
+        // Server sends data and is blocked by small stream flow control.
+        let mut r = pipe.server.writable();
+        assert_eq!(r.next(), Some(0));
+        assert_eq!(r.next(), None);
+
+        assert_eq!(pipe.server.stream_send(0, b"helloworld", false), Ok(5));
+        assert_eq!(pipe.advance(), Ok(()));
+
+        // Client reads to give flow control back.
+        assert_eq!(pipe.client.stream_recv(0, &mut b), Ok((5, false)));
+        assert_eq!(pipe.advance(), Ok(()));
+
+        // Server writes stream data and resets the stream before sending a
+        // packet.
+        assert_eq!(pipe.server.stream_send(0, b"world", false), Ok(5));
+        pipe.server.stream_shutdown(0, Shutdown::Write, 42).unwrap();
+        assert_eq!(pipe.advance(), Ok(()));
+
+        // Client has ACK'd the RESET_STREAM so the stream is collected.
+        assert_eq!(pipe.server.streams.len(), 0);
+    }
+
+    #[test]
     /// Tests that the MAX_STREAMS frame is sent for bidirectional streams.
     fn stream_limit_update_bidi() {
         let mut config = Config::new(crate::PROTOCOL_VERSION).unwrap();
@@ -16833,11 +16980,7 @@
         assert_eq!(pipe.server.stream_writable(0, 0), Ok(true));
 
         // Server sends data on stream 0, until blocked.
-        loop {
-            if pipe.server.stream_send(0, b"world", false) == Err(Error::Done) {
-                break;
-            }
-
+        while pipe.server.stream_send(0, b"world", false) != Err(Error::Done) {
             assert_eq!(pipe.advance(), Ok(()));
         }
 
diff --git a/quiche/src/stream/send_buf.rs b/quiche/src/stream/send_buf.rs
index a9bcc6c..10f4e54 100644
--- a/quiche/src/stream/send_buf.rs
+++ b/quiche/src/stream/send_buf.rs
@@ -356,12 +356,12 @@
         // Drop all buffered data.
         self.data.clear();
 
-        // Mark all data as acked.
+        // Mark relevant data as acked.
+        self.off = unsent_off;
         self.ack(0, self.off as usize);
 
         self.pos = 0;
         self.len = 0;
-        self.off = unsent_off;
 
         (self.emit_off, unsent_len)
     }