1use std::borrow::Cow;
2use std::time::Duration;
3
4use thiserror::Error;
5
6pub(crate) const DEFAULT_MAX_LINE_BYTES: usize = 4 * 1024 * 1024;
7pub(crate) const DEFAULT_MAX_EVENT_BYTES: usize = 16 * 1024 * 1024;
8const UTF8_BOM: [u8; 3] = [0xEF, 0xBB, 0xBF];
9
10#[derive(Debug, Clone, PartialEq, Eq)]
12pub struct SseMessage {
13 pub event: Option<String>,
15 pub data: String,
17 pub id: Option<String>,
19}
20
21#[derive(Debug, Clone, PartialEq, Eq)]
23pub enum SseEvent {
24 Message(SseMessage),
26 Retry(Duration),
28}
29
30#[derive(Debug, Clone, Copy, PartialEq, Eq)]
32pub enum SseUtf8Policy {
33 Replace,
35 Strict,
37}
38
39#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
41pub enum TailPolicy {
42 #[default]
44 Discard,
45 Flush,
53}
54
55#[derive(Debug, Clone, PartialEq, Eq, Error)]
57pub enum SseError {
58 #[error("invalid UTF-8 in an SSE field (strict mode)")]
60 Utf8,
61
62 #[error("SSE line exceeded {limit} bytes")]
64 LineTooLong { limit: usize },
65
66 #[error("SSE event exceeded {limit} bytes")]
68 EventTooLarge { limit: usize },
69}
70
71pub struct SseParser {
78 line: Vec<u8>,
79 pending_cr: bool,
80 bom_checked: bool,
81 bom_prefix: [u8; UTF8_BOM.len()],
82 bom_prefix_len: u8,
83
84 event_type: Option<String>,
85 data: Vec<u8>,
86 last_event_id: Option<String>,
87 retry: Option<Duration>,
88
89 max_line_bytes: usize,
90 max_event_bytes: usize,
91 utf8_policy: SseUtf8Policy,
92 tail_policy: TailPolicy,
93}
94
95impl Default for SseParser {
96 fn default() -> Self {
97 Self::new()
98 }
99}
100
101impl SseParser {
102 pub fn new() -> Self {
105 Self::with_limits(DEFAULT_MAX_LINE_BYTES, DEFAULT_MAX_EVENT_BYTES)
106 }
107
108 pub fn strict() -> Self {
110 Self::new().with_utf8_policy(SseUtf8Policy::Strict)
111 }
112
113 pub fn with_limits(max_line_bytes: usize, max_event_bytes: usize) -> Self {
117 Self {
118 line: Vec::with_capacity(256),
119 pending_cr: false,
120 bom_checked: false,
121 bom_prefix: [0; UTF8_BOM.len()],
122 bom_prefix_len: 0,
123 event_type: None,
124 data: Vec::with_capacity(1024),
125 last_event_id: None,
126 retry: None,
127 max_line_bytes,
128 max_event_bytes,
129 utf8_policy: SseUtf8Policy::Replace,
130 tail_policy: TailPolicy::Discard,
131 }
132 }
133
134 pub(crate) fn with_byte_limits(mut self, line: usize, event: usize) -> Self {
136 self.max_line_bytes = line;
137 self.max_event_bytes = event;
138 self
139 }
140
141 pub fn with_utf8_policy(mut self, utf8_policy: SseUtf8Policy) -> Self {
143 self.utf8_policy = utf8_policy;
144 self
145 }
146
147 pub fn with_tail_policy(mut self, tail_policy: TailPolicy) -> Self {
150 self.tail_policy = tail_policy;
151 self
152 }
153
154 pub fn tail_policy(&self) -> TailPolicy {
156 self.tail_policy
157 }
158
159 pub fn with_last_event_id(mut self, last_event_id: impl Into<String>) -> Self {
162 self.last_event_id = Some(last_event_id.into());
163 self
164 }
165
166 pub fn last_event_id(&self) -> Option<&str> {
168 self.last_event_id.as_deref()
169 }
170
171 pub fn retry(&self) -> Option<Duration> {
173 self.retry
174 }
175
176 pub fn reset(&mut self) {
179 self.clear_pending();
180 self.last_event_id = None;
181 self.retry = None;
182 }
183
184 pub fn reset_for_reconnect(&mut self) {
187 self.clear_pending();
188 }
189
190 fn clear_pending(&mut self) {
191 self.line.clear();
192 self.pending_cr = false;
193 self.bom_checked = false;
194 self.bom_prefix_len = 0;
195 self.event_type = None;
196 self.data.clear();
197 }
198
199 pub fn push(&mut self, chunk: &[u8]) -> Result<Vec<SseEvent>, SseError> {
201 let mut events = Vec::new();
202 self.push_into(chunk, &mut events)?;
203 Ok(events)
204 }
205
206 pub fn push_into(&mut self, chunk: &[u8], events: &mut Vec<SseEvent>) -> Result<(), SseError> {
210 let mut input = chunk;
211
212 if !self.bom_checked {
213 let prefix_len = usize::from(self.bom_prefix_len);
214 let needed = UTF8_BOM.len().saturating_sub(prefix_len);
215 let take = needed.min(input.len());
216 self.bom_prefix[prefix_len..prefix_len + take].copy_from_slice(&input[..take]);
217 self.bom_prefix_len += take as u8;
218 input = &input[take..];
219
220 let prefix_len = usize::from(self.bom_prefix_len);
221 if prefix_len < UTF8_BOM.len() && UTF8_BOM.starts_with(&self.bom_prefix[..prefix_len]) {
222 return Ok(());
223 }
224
225 self.bom_checked = true;
226 if self.bom_prefix[..prefix_len] != UTF8_BOM {
227 let mut prefix = [0_u8; UTF8_BOM.len()];
228 prefix[..prefix_len].copy_from_slice(&self.bom_prefix[..prefix_len]);
229 self.feed_bytes(&prefix[..prefix_len], events)?;
230 }
231 }
232
233 self.feed_bytes(input, events)
234 }
235
236 pub fn finish(&mut self) -> Result<Vec<SseEvent>, SseError> {
238 let mut events = Vec::new();
239 self.finish_into(&mut events)?;
240 Ok(events)
241 }
242
243 pub fn finish_into(&mut self, events: &mut Vec<SseEvent>) -> Result<(), SseError> {
245 if !self.bom_checked {
246 self.bom_checked = true;
247 let prefix_len = usize::from(self.bom_prefix_len);
248 if prefix_len != 0 && self.bom_prefix[..prefix_len] != UTF8_BOM {
249 let mut prefix = [0_u8; UTF8_BOM.len()];
250 prefix[..prefix_len].copy_from_slice(&self.bom_prefix[..prefix_len]);
251 self.feed_bytes(&prefix[..prefix_len], events)?;
252 }
253 }
254
255 if self.tail_policy == TailPolicy::Discard {
256 self.line.clear();
260 self.event_type = None;
261 self.data.clear();
262 self.pending_cr = false;
263 return Ok(());
264 }
265
266 if self.pending_cr {
269 self.pending_cr = false;
271 self.end_line(events)?;
272 }
273 if !self.line.is_empty() {
274 let line = std::mem::take(&mut self.line);
275 self.process_line(&line, events)?;
276 }
277 if self.data.is_empty() {
278 self.event_type = None;
279 } else {
280 self.dispatch(events);
281 }
282 Ok(())
283 }
284
285 fn feed_bytes(&mut self, bytes: &[u8], events: &mut Vec<SseEvent>) -> Result<(), SseError> {
286 let mut input = bytes;
287
288 loop {
289 if self.pending_cr {
290 self.pending_cr = false;
291 if input.first() == Some(&b'\n') {
292 input = &input[1..];
293 }
294 }
295
296 let Some(delimiter) = input.iter().position(|byte| matches!(*byte, b'\r' | b'\n'))
297 else {
298 self.push_line_bytes(input)?;
299 return Ok(());
300 };
301
302 let delimiter_byte = input[delimiter];
303 let segment = &input[..delimiter];
304 input = &input[delimiter + 1..];
305 self.finish_line_segment(segment, events)?;
306
307 if delimiter_byte == b'\r' {
308 if input.first() == Some(&b'\n') {
309 input = &input[1..];
310 } else if input.is_empty() {
311 self.pending_cr = true;
312 return Ok(());
313 }
314 }
315
316 if input.is_empty() {
317 return Ok(());
318 }
319 }
320 }
321
322 fn finish_line_segment(
323 &mut self,
324 segment: &[u8],
325 events: &mut Vec<SseEvent>,
326 ) -> Result<(), SseError> {
327 if self.line.is_empty() {
328 if segment.is_empty() {
329 self.dispatch(events);
330 return Ok(());
331 }
332 return self.process_line(segment, events);
333 }
334
335 self.push_line_bytes(segment)?;
336 self.end_line(events)
337 }
338
339 fn push_line_bytes(&mut self, value: &[u8]) -> Result<(), SseError> {
340 let next_len = self
341 .line
342 .len()
343 .checked_add(value.len())
344 .ok_or(SseError::LineTooLong {
345 limit: self.max_line_bytes,
346 })?;
347 if next_len > self.max_line_bytes {
348 return Err(SseError::LineTooLong {
349 limit: self.max_line_bytes,
350 });
351 }
352 self.line.extend_from_slice(value);
353 Ok(())
354 }
355
356 fn end_line(&mut self, events: &mut Vec<SseEvent>) -> Result<(), SseError> {
357 if self.line.is_empty() {
358 self.dispatch(events);
359 return Ok(());
360 }
361
362 let mut line = std::mem::take(&mut self.line);
363 let result = self.process_line(&line, events);
364 line.clear();
365 self.line = line;
366 result
367 }
368
369 fn process_line(&mut self, line: &[u8], events: &mut Vec<SseEvent>) -> Result<(), SseError> {
370 if line.first() == Some(&b':') {
371 return Ok(());
372 }
373
374 let (field, value) = split_field(line);
375
376 match field {
377 b"data" => self.append_data(value)?,
378 b"event" => {
379 self.event_type = Some(self.decode(value)?.into_owned());
380 }
381 b"id" => {
382 if !value.contains(&0) {
383 self.last_event_id = Some(self.decode(value)?.into_owned());
384 }
385 }
386 b"retry" => {
387 if let Some(millis) = parse_retry(value) {
388 let retry = Duration::from_millis(millis);
389 self.retry = Some(retry);
390 events.push(SseEvent::Retry(retry));
391 }
392 }
393 _ => {}
394 }
395
396 Ok(())
397 }
398
399 fn append_data(&mut self, value: &[u8]) -> Result<(), SseError> {
400 let value = self.decode(value)?;
401 let next_len = self
402 .data
403 .len()
404 .checked_add(value.len())
405 .and_then(|len| len.checked_add(1))
406 .ok_or(SseError::EventTooLarge {
407 limit: self.max_event_bytes,
408 })?;
409
410 if next_len > self.max_event_bytes {
411 return Err(SseError::EventTooLarge {
412 limit: self.max_event_bytes,
413 });
414 }
415
416 self.data.extend_from_slice(value.as_bytes());
417 self.data.push(b'\n');
418 Ok(())
419 }
420
421 fn decode<'a>(&self, value: &'a [u8]) -> Result<Cow<'a, str>, SseError> {
422 match self.utf8_policy {
423 SseUtf8Policy::Replace => Ok(String::from_utf8_lossy(value)),
424 SseUtf8Policy::Strict => std::str::from_utf8(value)
425 .map(Cow::Borrowed)
426 .map_err(|_| SseError::Utf8),
427 }
428 }
429
430 fn dispatch(&mut self, events: &mut Vec<SseEvent>) {
431 if self.data.is_empty() {
432 self.event_type = None;
433 return;
434 }
435
436 self.data.pop(); let Ok(data) = String::from_utf8(std::mem::take(&mut self.data)) else {
438 self.event_type = None;
440 return;
441 };
442
443 events.push(SseEvent::Message(SseMessage {
444 event: self.event_type.take(),
445 data,
446 id: self.last_event_id.clone(),
447 }));
448 }
449}
450
451fn split_field(line: &[u8]) -> (&[u8], &[u8]) {
452 let Some(colon) = line.iter().position(|byte| *byte == b':') else {
453 return (line, &[]);
454 };
455
456 let mut value = &line[colon + 1..];
457 if value.first() == Some(&b' ') {
458 value = &value[1..];
459 }
460 (&line[..colon], value)
461}
462
463fn parse_retry(value: &[u8]) -> Option<u64> {
464 if value.is_empty() || !value.iter().all(u8::is_ascii_digit) {
465 return None;
466 }
467
468 let mut result = 0_u64;
469 for byte in value {
470 result = result
471 .checked_mul(10)?
472 .checked_add(u64::from(byte - b'0'))?;
473 }
474 Some(result)
475}
476
477#[cfg(test)]
478mod tests {
479 use super::*;
480
481 fn message(data: &str) -> SseEvent {
482 SseEvent::Message(SseMessage {
483 event: None,
484 data: data.to_string(),
485 id: None,
486 })
487 }
488
489 #[test]
490 fn reset_for_reconnect_preserves_last_event_id() {
491 let mut parser = SseParser::new();
492 parser.push(b"id: 42\ndata: first\n\n").unwrap();
493 parser.reset_for_reconnect();
494
495 assert_eq!(parser.last_event_id(), Some("42"));
496 let events = parser.push(b"data: second\n\n").unwrap();
497 assert_eq!(
498 events,
499 vec![SseEvent::Message(SseMessage {
500 event: None,
501 data: "second".to_string(),
502 id: Some("42".to_string()),
503 })]
504 );
505 }
506
507 #[test]
508 fn parses_basic_event() {
509 let mut parser = SseParser::new();
510 let events = parser.push(b"data: hello\n\n").unwrap();
511 assert_eq!(events, vec![message("hello")]);
512 }
513
514 #[test]
515 fn push_into_reuses_event_buffer() {
516 let mut parser = SseParser::new();
517 let mut events = Vec::new();
518
519 parser.push_into(b"data: one\n\n", &mut events).unwrap();
520 assert_eq!(events, vec![message("one")]);
521
522 events.clear();
523 parser.push_into(b"data: two\n\n", &mut events).unwrap();
524 assert_eq!(events, vec![message("two")]);
525 }
526
527 #[test]
528 fn parses_multiline_data() {
529 let mut parser = SseParser::new();
530 let events = parser.push(b"data: hello\ndata: world\n\n").unwrap();
531 assert_eq!(events, vec![message("hello\nworld")]);
532 }
533
534 #[test]
535 fn handles_every_byte_boundary() {
536 let input = b"event: update\nid: 42\ndata: hello\ndata: world\n\n";
537 for split in 0..input.len() {
538 let mut parser = SseParser::new();
539 let mut events = parser.push(&input[..split]).unwrap();
540 events.extend(parser.push(&input[split..]).unwrap());
541 assert_eq!(events.len(), 1, "split={split}");
542 assert_eq!(
543 events[0],
544 SseEvent::Message(SseMessage {
545 event: Some("update".to_string()),
546 data: "hello\nworld".to_string(),
547 id: Some("42".to_string()),
548 })
549 );
550 }
551 }
552
553 #[test]
554 fn handles_crlf_split_across_chunks() {
555 let mut parser = SseParser::new();
556 assert!(parser.push(b"data: hello\r").unwrap().is_empty());
557 let events = parser.push(b"\n\r\n").unwrap();
558 assert_eq!(events, vec![message("hello")]);
559 }
560
561 #[test]
562 fn ignores_bom_split_across_chunks() {
563 let mut parser = SseParser::new();
564 assert!(parser.push(&UTF8_BOM[..1]).unwrap().is_empty());
565 assert!(parser.push(&UTF8_BOM[1..]).unwrap().is_empty());
566 let events = parser.push(b"data: hello\n\n").unwrap();
567 assert_eq!(events, vec![message("hello")]);
568 }
569
570 #[test]
571 fn emits_retry_and_keeps_last_id() {
572 let mut parser = SseParser::new();
573 let events = parser.push(b"retry: 1500\nid: 7\ndata: hi\n\n").unwrap();
574 assert_eq!(
575 events,
576 vec![
577 SseEvent::Retry(Duration::from_millis(1500)),
578 SseEvent::Message(SseMessage {
579 event: None,
580 data: "hi".to_string(),
581 id: Some("7".to_string()),
582 }),
583 ]
584 );
585 assert_eq!(parser.last_event_id(), Some("7"));
586 assert_eq!(parser.retry(), Some(Duration::from_millis(1500)));
587 }
588
589 #[test]
590 fn ignores_comments_and_unknown_fields() {
591 let mut parser = SseParser::new();
592 let events = parser
593 .push(b": keepalive\nunknown: value\ndata: hi\n\n")
594 .unwrap();
595 assert_eq!(events, vec![message("hi")]);
596 }
597
598 #[test]
599 fn empty_data_field_dispatches_empty_message() {
600 let mut parser = SseParser::new();
601 let events = parser.push(b"data:\n\n").unwrap();
602 assert_eq!(events, vec![message("")]);
603 }
604
605 #[test]
606 fn no_data_field_does_not_dispatch() {
607 let mut parser = SseParser::new();
608 let events = parser.push(b"event: ping\n\n").unwrap();
609 assert!(events.is_empty());
610 }
611
612 #[test]
613 fn discards_incomplete_final_event() {
614 let mut parser = SseParser::new();
615 let events = parser.push(b"data: incomplete").unwrap();
616 assert!(events.is_empty());
617 assert!(parser.finish().unwrap().is_empty());
618 }
619
620 #[test]
621 fn flush_policy_dispatches_final_data_line_without_blank_terminator() {
622 let mut parser = SseParser::new().with_tail_policy(TailPolicy::Flush);
623 let mut events = parser.push(b"data: {\"q\":1}").unwrap();
624 assert!(events.is_empty());
625 parser.finish_into(&mut events).unwrap();
626 assert_eq!(events, vec![message("{\"q\":1}")]);
627 }
628
629 #[test]
630 fn flush_policy_flushes_aggregated_multi_data_tail() {
631 let mut parser = SseParser::new().with_tail_policy(TailPolicy::Flush);
632 let mut events = parser.push(b"data: A\ndata: B").unwrap();
633 parser.finish_into(&mut events).unwrap();
634 assert_eq!(events, vec![message("A\nB")]);
635 }
636
637 #[test]
638 fn flush_policy_treats_trailing_bare_cr_as_terminator() {
639 let mut parser = SseParser::new().with_tail_policy(TailPolicy::Flush);
640 let mut events = parser.push(b"data: hi\r").unwrap();
641 parser.finish_into(&mut events).unwrap();
642 assert_eq!(events, vec![message("hi")]);
643 }
644
645 #[test]
646 fn flush_policy_ignores_partial_unknown_field_tail() {
647 let mut parser = SseParser::new().with_tail_policy(TailPolicy::Flush);
648 let mut events = parser.push(b"data: hi\neven").unwrap();
649 parser.finish_into(&mut events).unwrap();
650 assert_eq!(events, vec![message("hi")]);
651 }
652
653 #[test]
654 fn flush_policy_without_pending_data_is_a_noop() {
655 let mut parser = SseParser::new().with_tail_policy(TailPolicy::Flush);
656 let events = parser.push(b"data: done\n\n").unwrap();
657 assert_eq!(events, vec![message("done")]);
658 let extra = parser.finish().unwrap();
659 assert!(extra.is_empty());
660 }
661
662 #[test]
663 fn enforces_line_limit() {
664 let mut parser = SseParser::with_limits(4, 1024);
665 assert_eq!(
666 parser.push(b"data: hello\n\n"),
667 Err(SseError::LineTooLong { limit: 4 })
668 );
669 }
670
671 #[test]
672 fn default_parser_accepts_large_responses_terminal_lines() {
673 let mut parser = SseParser::new();
674 let payload = format!("data: {}\n\n", "x".repeat(128 * 1024));
675 assert!(parser.push(payload.as_bytes()).is_ok());
676 }
677
678 #[test]
679 fn enforces_event_limit() {
680 let mut parser = SseParser::with_limits(1024, 4);
681 assert_eq!(
682 parser.push(b"data: hello\n\n"),
683 Err(SseError::EventTooLarge { limit: 4 })
684 );
685 }
686
687 #[test]
688 fn replaces_invalid_utf8_by_default() {
689 let mut parser = SseParser::new();
690 let events = parser.push(b"data: \xFF\n\n").unwrap();
691 assert_eq!(events, vec![message("\u{FFFD}")]);
692 }
693
694 #[test]
695 fn strict_mode_rejects_invalid_utf8() {
696 let mut parser = SseParser::strict();
697 assert_eq!(parser.push(b"data: \xFF\n\n"), Err(SseError::Utf8));
698 }
699
700 #[test]
701 fn last_event_id_persists_without_new_id() {
702 let mut parser = SseParser::new();
703 let events = parser.push(b"id: 7\ndata: one\n\ndata: two\n\n").unwrap();
704 assert_eq!(events.len(), 2);
705 assert_eq!(
706 events[0],
707 SseEvent::Message(SseMessage {
708 event: None,
709 data: "one".to_string(),
710 id: Some("7".to_string()),
711 })
712 );
713 assert_eq!(
714 events[1],
715 SseEvent::Message(SseMessage {
716 event: None,
717 data: "two".to_string(),
718 id: Some("7".to_string()),
719 })
720 );
721 }
722
723 #[test]
724 fn event_type_resets_after_dispatch() {
725 let mut parser = SseParser::new();
726 let events = parser
727 .push(b"event: update\ndata: one\n\ndata: two\n\n")
728 .unwrap();
729 assert_eq!(events.len(), 2);
730 assert_eq!(
731 events[0],
732 SseEvent::Message(SseMessage {
733 event: Some("update".to_string()),
734 data: "one".to_string(),
735 id: None,
736 })
737 );
738 assert_eq!(events[1], message("two"));
739 }
740
741 #[test]
742 fn invalid_and_overflowing_retry_values_are_ignored() {
743 let mut parser = SseParser::new();
744 let events = parser
745 .push(b"retry: nope\nretry: 18446744073709551616\ndata: hi\n\n")
746 .unwrap();
747 assert_eq!(events, vec![message("hi")]);
748 assert_eq!(parser.retry(), None);
749 }
750
751 #[test]
752 fn handles_cr_only_line_endings() {
753 let mut parser = SseParser::new();
754 let mut events = parser.push(b"data: hello\r\r").unwrap();
755 events.extend(parser.finish().unwrap());
756 assert_eq!(events, vec![message("hello")]);
757 }
758
759 #[test]
760 fn removes_only_one_leading_space() {
761 let mut parser = SseParser::new();
762 let events = parser.push(b"data: hello\n\n").unwrap();
763 assert_eq!(events, vec![message(" hello")]);
764 }
765
766 #[test]
767 fn ignores_id_containing_nul() {
768 let mut parser = SseParser::new();
769 let events = parser.push(b"id: a\x00b\ndata: hi\n\n").unwrap();
770 assert_eq!(events, vec![message("hi")]);
771 assert_eq!(parser.last_event_id(), None);
772 }
773
774 #[test]
775 fn colonless_data_is_an_empty_data_field() {
776 let mut parser = SseParser::new();
777 let events = parser.push(b"data\n\n").unwrap();
778 assert_eq!(events, vec![message("")]);
779 }
780
781 #[test]
782 fn parses_cjk_data() {
783 let mut parser = SseParser::new();
784 let events = parser.push("data: 你好,世界\n\n".as_bytes()).unwrap();
785 assert_eq!(events, vec![message("你好,世界")]);
786 }
787
788 #[test]
789 fn parses_cjk_split_inside_codepoints() {
790 let input = "data: 中文\n\n".as_bytes();
791 for split in 0..input.len() {
792 let mut parser = SseParser::new();
793 let mut events = parser.push(&input[..split]).unwrap();
794 events.extend(parser.push(&input[split..]).unwrap());
795 assert_eq!(events, vec![message("中文")], "split={split}");
796 }
797 }
798
799 #[test]
800 fn parses_cjk_event_and_id() {
801 let mut parser = SseParser::new();
802 let events = parser
803 .push("event: 更新\nid: 会话-7\ndata: 内容\n\n".as_bytes())
804 .unwrap();
805 assert_eq!(
806 events,
807 vec![SseEvent::Message(SseMessage {
808 event: Some("更新".to_string()),
809 data: "内容".to_string(),
810 id: Some("会话-7".to_string()),
811 })]
812 );
813 }
814
815 #[test]
816 fn parses_emoji_split_inside_codepoint() {
817 let input = "data: 🦀🚀\n\n".as_bytes();
818 for split in 0..input.len() {
819 let mut parser = SseParser::new();
820 let mut events = parser.push(&input[..split]).unwrap();
821 events.extend(parser.push(&input[split..]).unwrap());
822 assert_eq!(events, vec![message("🦀🚀")], "split={split}");
823 }
824 }
825
826 #[test]
827 fn line_limit_counts_utf8_bytes() {
828 let mut parser = SseParser::with_limits(8, 1024);
829 assert_eq!(
830 parser.push("data: 中文\n\n".as_bytes()),
831 Err(SseError::LineTooLong { limit: 8 })
832 );
833 }
834
835 #[test]
836 fn bom_before_cjk_is_ignored() {
837 let mut parser = SseParser::new();
838 let mut input = UTF8_BOM.to_vec();
839 input.extend_from_slice("data: 中文\n\n".as_bytes());
840 let events = parser.push(&input).unwrap();
841 assert_eq!(events, vec![message("中文")]);
842 }
843
844 #[test]
845 fn partial_bom_at_eof_is_discarded() {
846 let mut parser = SseParser::new();
847 assert!(parser.push(&UTF8_BOM[..2]).unwrap().is_empty());
848 assert!(parser.finish().unwrap().is_empty());
849 }
850}