@@ -442,171 +442,3 @@ impl std::fmt::Display for PacketType {
442
442
std:: fmt:: Debug :: fmt ( & self , f)
443
443
}
444
444
}
445
-
446
- #[ cfg( test) ]
447
- mod tests {
448
-
449
- use bytes:: BytesMut ;
450
-
451
- use crate :: packets:: Packet ;
452
-
453
- use crate :: tests:: test_packets:: * ;
454
-
455
- #[ rstest:: rstest]
456
- #[ case:: connect_case( connect_case( ) ) ]
457
- #[ case:: ping_req_case( ping_req_case( ) . 1 ) ]
458
- #[ case:: ping_resp_case( ping_resp_case( ) . 1 ) ]
459
- #[ case:: connack_case( connack_case( ) . 1 ) ]
460
- #[ case:: create_subscribe_packet( create_subscribe_packet( 1 ) ) ]
461
- #[ case:: create_subscribe_packet( create_subscribe_packet( 65335 ) ) ]
462
- #[ case:: create_puback_packet( create_puback_packet( 1 ) ) ]
463
- #[ case:: create_puback_packet( create_puback_packet( 65335 ) ) ]
464
- #[ case:: create_disconnect_packet( create_disconnect_packet( ) ) ]
465
- #[ case:: create_connack_packet( create_connack_packet( true ) ) ]
466
- #[ case:: create_connack_packet( create_connack_packet( false ) ) ]
467
- #[ case:: publish_packet_1( publish_packet_1( ) ) ]
468
- #[ case:: publish_packet_2( publish_packet_2( ) ) ]
469
- #[ case:: publish_packet_3( publish_packet_3( ) ) ]
470
- #[ case:: publish_packet_4( publish_packet_4( ) ) ]
471
- #[ case:: create_empty_publish_packet( create_empty_publish_packet( ) ) ]
472
- #[ case:: subscribe( subscribe_case( ) ) ]
473
- #[ case:: suback( suback_case( ) ) ]
474
- #[ case:: unsubscribe( unsubscribe_case( ) ) ]
475
- #[ case:: unsuback( unsuback_case( ) ) ]
476
- #[ case:: pubcomp_case( pubcomp_case( ) ) ]
477
- #[ case:: pubrec_case( pubrec_case( ) ) ]
478
- #[ case:: pubrec_case( pubrel_case2( ) ) ]
479
- #[ case:: auth_case( auth_case( ) ) ]
480
- fn test_write_read_write_read_cases ( #[ case] packet : Packet ) {
481
- use crate :: packets:: WireLength ;
482
-
483
- let mut buffer = BytesMut :: new ( ) ;
484
-
485
- packet. write ( & mut buffer) . unwrap ( ) ;
486
-
487
- let wire_len = packet. wire_len ( ) ;
488
- assert_eq ! ( wire_len, buffer. len( ) ) ;
489
-
490
- // dbg!(wire_len);
491
-
492
- // let a: Vec<_> = buffer.iter().map(|f| *f as u16).collect();
493
- // println!("{:?}", a);
494
-
495
- let res1 = Packet :: read ( & mut buffer) . unwrap ( ) ;
496
-
497
- assert_eq ! ( packet, res1) ;
498
-
499
- let mut buffer = BytesMut :: new ( ) ;
500
- res1. write ( & mut buffer) . unwrap ( ) ;
501
- let res2 = Packet :: read ( & mut buffer) . unwrap ( ) ;
502
-
503
- assert_eq ! ( res1, res2) ;
504
- }
505
-
506
- #[ rstest:: rstest]
507
- #[ case:: connect_case( connect_case( ) ) ]
508
- #[ case:: ping_req_case( ping_req_case( ) . 1 ) ]
509
- #[ case:: ping_resp_case( ping_resp_case( ) . 1 ) ]
510
- #[ case:: connack_case( connack_case( ) . 1 ) ]
511
- #[ case:: create_subscribe_packet( create_subscribe_packet( 1 ) ) ]
512
- #[ case:: create_subscribe_packet( create_subscribe_packet( 65335 ) ) ]
513
- #[ case:: create_puback_packet( create_puback_packet( 1 ) ) ]
514
- #[ case:: create_puback_packet( create_puback_packet( 65335 ) ) ]
515
- #[ case:: create_disconnect_packet( create_disconnect_packet( ) ) ]
516
- #[ case:: create_connack_packet( create_connack_packet( true ) ) ]
517
- #[ case:: create_connack_packet( create_connack_packet( false ) ) ]
518
- #[ case:: publish_packet_1( publish_packet_1( ) ) ]
519
- #[ case:: publish_packet_2( publish_packet_2( ) ) ]
520
- #[ case:: publish_packet_3( publish_packet_3( ) ) ]
521
- #[ case:: publish_packet_4( publish_packet_4( ) ) ]
522
- #[ case:: create_empty_publish_packet( create_empty_publish_packet( ) ) ]
523
- #[ case:: subscribe( subscribe_case( ) ) ]
524
- #[ case:: suback( suback_case( ) ) ]
525
- #[ case:: unsubscribe( unsubscribe_case( ) ) ]
526
- #[ case:: unsuback( unsuback_case( ) ) ]
527
- #[ case:: pubcomp_case( pubcomp_case( ) ) ]
528
- #[ case:: pubrec_case( pubrec_case( ) ) ]
529
- #[ case:: pubrec_case( pubrel_case2( ) ) ]
530
- #[ case:: auth_case( auth_case( ) ) ]
531
- #[ tokio:: test]
532
- async fn test_async_write_read_write_read_cases ( #[ case] packet : Packet ) {
533
- use crate :: packets:: WireLength ;
534
-
535
- let mut buffer = Vec :: with_capacity ( 1000 ) ;
536
- let res = packet. async_write ( & mut buffer) . await . unwrap ( ) ;
537
-
538
- let wire_len = packet. wire_len ( ) ;
539
-
540
- assert_eq ! ( res, buffer. len( ) ) ;
541
- assert_eq ! ( wire_len, buffer. len( ) ) ;
542
-
543
- let mut buf = buffer. as_slice ( ) ;
544
-
545
- let res1 = Packet :: async_read ( & mut buf) . await . unwrap ( ) ;
546
-
547
- pretty_assertions:: assert_eq!( packet, res1) ;
548
- }
549
-
550
- #[ rstest:: rstest]
551
- #[ case:: disconnect( disconnect_case( ) ) ]
552
- #[ case:: ping_req( ping_req_case( ) ) ]
553
- #[ case:: ping_resp( ping_resp_case( ) ) ]
554
- #[ case:: publish( publish_case( ) ) ]
555
- #[ case:: pubrel( pubrel_case( ) ) ]
556
- #[ case:: pubrel_smallest( pubrel_smallest_case( ) ) ]
557
- fn test_read_write_cases ( #[ case] ( bytes, expected_packet) : ( & [ u8 ] , Packet ) ) {
558
- let mut buffer = BytesMut :: from_iter ( bytes) ;
559
-
560
- let res = Packet :: read ( & mut buffer) ;
561
-
562
- assert ! ( res. is_ok( ) ) ;
563
-
564
- let packet = res. unwrap ( ) ;
565
-
566
- assert_eq ! ( packet, expected_packet) ;
567
-
568
- buffer. clear ( ) ;
569
-
570
- packet. write ( & mut buffer) . unwrap ( ) ;
571
-
572
- assert_eq ! ( buffer. to_vec( ) , bytes. to_vec( ) )
573
- }
574
-
575
- #[ rstest:: rstest]
576
- #[ case:: disconnect( disconnect_case( ) ) ]
577
- #[ case:: ping_req( ping_req_case( ) ) ]
578
- #[ case:: ping_resp( ping_resp_case( ) ) ]
579
- #[ case:: publish( publish_case( ) ) ]
580
- #[ case:: pubrel( pubrel_case( ) ) ]
581
- #[ case:: pubrel_smallest( pubrel_smallest_case( ) ) ]
582
- #[ tokio:: test]
583
- async fn test_async_read_write ( #[ case] ( mut bytes, expected_packet) : ( & [ u8 ] , Packet ) ) {
584
- let input = bytes. to_vec ( ) ;
585
-
586
- let res = Packet :: async_read ( & mut bytes) . await ;
587
-
588
- dbg ! ( & res) ;
589
- assert ! ( res. is_ok( ) ) ;
590
-
591
- let packet = res. unwrap ( ) ;
592
-
593
- assert_eq ! ( packet, expected_packet) ;
594
-
595
- let mut out = Vec :: with_capacity ( 1000 ) ;
596
-
597
- packet. async_write ( & mut out) . await . unwrap ( ) ;
598
-
599
- assert_eq ! ( out, input)
600
- }
601
-
602
- // #[rstest::rstest]
603
- // #[case(&[59, 1, 0, 59])]
604
- // #[case(&[16, 14, 0, 4, 77, 81, 84, 84, 5, 247, 247, 252, 1, 17, 247, 247, 247])]
605
- // fn test_read_error(#[case] bytes: &[u8]) {
606
- // let mut buffer = BytesMut::from_iter(bytes);
607
-
608
- // let res = Packet::read_from_buffer(&mut buffer);
609
-
610
- // assert!(res.is_err());
611
- // }
612
- }
0 commit comments