@@ -1627,7 +1627,7 @@ async fn test_overlay_semiprivate() -> Result<()> {
16271627fn test_overlay_raptorq ( ) {
16281628 use rand:: { seq:: SliceRandom , SeedableRng } ;
16291629
1630- fn run ( symbol : Option < u16 > ) {
1630+ fn run ( symbol : Option < u32 > ) {
16311631 let seed: u64 = rand:: random ( ) ;
16321632 println ! ( "test_overlay_raptorq seed: {seed}" ) ;
16331633 let mut rng = rand:: rngs:: StdRng :: seed_from_u64 ( seed) ;
@@ -1778,3 +1778,94 @@ fn test_overlay_raptorq() {
17781778 println ! ( "--- symbol=Some(771) (alignment=1) ---" ) ;
17791779 run ( Some ( 771 ) ) ;
17801780}
1781+
1782+ /// Test that RaptorQ encode/decode works with symbol_size > 65535 (u16 limit).
1783+ /// This matches the C++ behaviour where symbol_size is size_t.
1784+ /// Simulates TwostepFec for 800KB data with 10 parties:
1785+ /// k = (10*2-2)/3 = 6, part_size = ceil(819200/6) = 136534
1786+ #[ test]
1787+ fn test_raptorq_large_symbol_size ( ) {
1788+ use adnl:: { RaptorqDecoder , RaptorqEncoder } ;
1789+ use rand:: Rng ;
1790+
1791+ const DATA_SIZE : usize = 800 * 1024 ;
1792+
1793+ for num_parties in [ 5u32 , 10 , 20 ] {
1794+ let k = ( ( num_parties as usize ) * 2 - 2 ) / 3 ;
1795+ let part_size = ( DATA_SIZE + k - 1 ) / k;
1796+
1797+ println ! (
1798+ "--- parties={num_parties}, k={k}, part_size={part_size} (>65535: {}) ---" ,
1799+ part_size > 65535
1800+ ) ;
1801+
1802+ // Generate random data
1803+ let mut rng = rand:: thread_rng ( ) ;
1804+ let data: Vec < u8 > = ( 0 ..DATA_SIZE ) . map ( |_| rng. gen ( ) ) . collect ( ) ;
1805+
1806+ // Encode with large symbol_size
1807+ let mut encoder = RaptorqEncoder :: with_data ( & data, Some ( part_size as u32 ) ) ;
1808+ let params = encoder. params ( ) . clone ( ) ;
1809+ println ! (
1810+ " params: data_size={}, symbol_size={}, symbols_count={}" ,
1811+ params. data_size, params. symbol_size, params. symbols_count
1812+ ) ;
1813+ assert_eq ! ( params. data_size, DATA_SIZE as i32 ) ;
1814+ assert_eq ! ( params. symbol_size, part_size as i32 ) ;
1815+
1816+ // Collect source + repair symbols
1817+ let source_count = params. symbols_count as usize ;
1818+ let mut packets: Vec < ( u32 , Vec < u8 > ) > = Vec :: new ( ) ;
1819+ let mut seqno = 0u32 ;
1820+ for _ in 0 ..( source_count * 3 / 2 ) {
1821+ let chunk = encoder. encode ( & mut seqno) . unwrap ( ) ;
1822+ packets. push ( ( seqno, chunk) ) ;
1823+ seqno += 1 ;
1824+ }
1825+ assert ! (
1826+ packets. len( ) >= source_count,
1827+ "Not enough packets generated: {} < {source_count}" ,
1828+ packets. len( )
1829+ ) ;
1830+
1831+ // Decode using exactly source_count symbols (minimum required)
1832+ let mut decoder = RaptorqDecoder :: with_params ( params. clone ( ) )
1833+ . expect ( "decoder creation must succeed for large symbol_size" ) ;
1834+
1835+ let mut decoded = None ;
1836+ for ( seq, chunk) in packets. iter ( ) . take ( source_count + 2 ) {
1837+ if let Some ( result) = decoder. decode ( * seq, chunk) {
1838+ decoded = Some ( result) ;
1839+ break ;
1840+ }
1841+ }
1842+
1843+ let result = decoded. expect ( "decode must succeed" ) ;
1844+ assert_eq ! ( result. len( ) , DATA_SIZE , "decoded size mismatch" ) ;
1845+ assert_eq ! ( result, data, "decoded data mismatch" ) ;
1846+ println ! ( " OK: encode/decode verified for symbol_size={part_size}" ) ;
1847+ }
1848+ }
1849+
1850+ /// Verify that the RaptorQ encoder produces valid FEC symbols for large
1851+ /// part_size values (>65535) that match the C++ TwostepFec behaviour.
1852+ #[ test]
1853+ fn test_twostep_fec_encoder_large_symbols ( ) {
1854+ let data = vec ! [ 0x42u8 ; 800 * 1024 ] ;
1855+ for neighbours in [ 5u32 , 10 , 20 ] {
1856+ let k = ( ( neighbours as usize ) * 2 - 2 ) / 3 ;
1857+ let part_size = ( data. len ( ) + k - 1 ) / k;
1858+
1859+ let mut encoder = RaptorqEncoder :: with_data ( & data, Some ( part_size as u32 ) ) ;
1860+ let params = encoder. params ( ) . clone ( ) ;
1861+ assert_eq ! ( params. data_size, data. len( ) as i32 ) ;
1862+ assert_eq ! ( params. symbol_size, part_size as i32 ) ;
1863+
1864+ // Generate one symbol per neighbour (like broadcast-twostep.cpp)
1865+ let mut seqno = 0u32 ;
1866+ for _ in 0 ..neighbours {
1867+ let chunk = encoder. encode ( & mut seqno) . unwrap ( ) ;
1868+ assert_eq ! ( chunk. len( ) , part_size, "symbol size mismatch" ) ;
1869+ }
1870+ }
1871+ }
0 commit comments