nihav-core/src/io/byteio.rs

   1 use std::io::SeekFrom;
   2 use std::fs::File;
   3 use std::io::prelude::*;
   4 use std::ptr;
   5
   6 #[derive(Debug)]
   7 pub enum ByteIOError {
   8     EOF,
   9     WrongRange,
  10     WrongIOMode,
  11     NotImplemented,
  12     ReadError,
  13     WriteError,
  14     SeekError,
  15 }
  16
  17 pub type ByteIOResult<T> = Result<T, ByteIOError>;
  18
  19 pub trait ByteIO {
  20     fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize>;
  21     fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize>;
  22     fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize>;
  23     fn read_byte(&mut self) -> ByteIOResult<u8>;
  24     fn peek_byte(&mut self) -> ByteIOResult<u8>;
  25     fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()>;
  26     fn tell(&mut self) -> u64;
  27     fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64>;
  28     fn is_eof(&self) -> bool;
  29     fn is_seekable(&mut self) -> bool;
  30     fn size(&mut self) -> i64;
  31 }
  32
  33 #[allow(dead_code)]
  34 pub struct ByteReader<'a> {
  35     io: &'a mut ByteIO,
  36 }
  37
  38 pub struct MemoryReader<'a> {
  39     buf:      &'a [u8],
  40     size:     usize,
  41     pos:      usize,
  42 }
  43
  44 pub struct FileReader<'a> {
  45     file:     &'a File,
  46     eof:      bool,
  47 }
  48
  49 macro_rules! read_int {
  50     ($s: ident, $inttype: ty, $size: expr, $which: ident) => ({
  51         unsafe {
  52             let mut buf: $inttype = 0;
  53             $s.read_buf(&mut *(&mut buf as *mut $inttype as *mut [u8; $size]))?;
  54             Ok(buf.$which())
  55         }
  56     })
  57 }
  58
  59 macro_rules! peek_int {
  60     ($s: ident, $inttype: ty, $size: expr, $which: ident) => ({
  61         unsafe {
  62             let mut buf: $inttype = 0;
  63             $s.peek_buf(&mut *(&mut buf as *mut $inttype as *mut [u8; $size]))?;
  64             Ok(buf.$which())
  65         }
  66     })
  67 }
  68
  69 macro_rules! read_int_func {
  70     ($s: ident, $inttype: ty, $size: expr, $which: ident) => {
  71         pub fn $s(src: &[u8]) -> ByteIOResult<$inttype> {
  72             if src.len() < $size { return Err(ByteIOError::ReadError); }
  73             unsafe {
  74                 let mut buf: $inttype = 0;
  75                 ptr::copy_nonoverlapping(src.as_ptr(), &mut buf as *mut $inttype as *mut u8, std::mem::size_of::<$inttype>());
  76                 Ok(buf.$which())
  77             }
  78         }
  79     }
  80 }
  81
  82 read_int_func!(read_u16be, u16, 2, to_be);
  83 read_int_func!(read_u16le, u16, 2, to_le);
  84 read_int_func!(read_u32be, u32, 4, to_be);
  85 read_int_func!(read_u32le, u32, 4, to_le);
  86 read_int_func!(read_u64be, u64, 8, to_be);
  87 read_int_func!(read_u64le, u64, 8, to_le);
  88
  89 pub fn read_u24be(src: &[u8]) -> ByteIOResult<u32> {
  90     if src.len() < 3 { return Err(ByteIOError::ReadError); }
  91     Ok((u32::from(src[0]) << 16) | (u32::from(src[1]) << 8) | u32::from(src[2]))
  92 }
  93 pub fn read_u24le(src: &[u8]) -> ByteIOResult<u32> {
  94     if src.len() < 3 { return Err(ByteIOError::ReadError); }
  95     Ok((u32::from(src[2]) << 16) | (u32::from(src[1]) << 8) | u32::from(src[0]))
  96 }
  97
  98 impl<'a> ByteReader<'a> {
  99     pub fn new(io: &'a mut ByteIO) -> Self { ByteReader { io } }
 100
 101     pub fn read_buf(&mut self, buf: &mut [u8])  -> ByteIOResult<usize> {
 102         self.io.read_buf(buf)
 103     }
 104
 105     pub fn read_buf_some(&mut self, buf: &mut [u8])  -> ByteIOResult<usize> {
 106         self.io.read_buf_some(buf)
 107     }
 108
 109     pub fn peek_buf(&mut self, buf: &mut [u8])  -> ByteIOResult<usize> {
 110         self.io.peek_buf(buf)
 111     }
 112
 113     pub fn read_byte(&mut self) -> ByteIOResult<u8> {
 114         self.io.read_byte()
 115     }
 116
 117     pub fn peek_byte(&mut self) -> ByteIOResult<u8> {
 118         self.io.peek_byte()
 119     }
 120
 121     pub fn read_u16be(&mut self) -> ByteIOResult<u16> {
 122         read_int!(self, u16, 2, to_be)
 123     }
 124
 125     pub fn peek_u16be(&mut self) -> ByteIOResult<u16> {
 126         peek_int!(self, u16, 2, to_be)
 127     }
 128
 129     pub fn read_u24be(&mut self) -> ByteIOResult<u32> {
 130         let p16 = self.read_u16be()?;
 131         let p8 = self.read_byte()?;
 132         Ok((u32::from(p16) << 8) | u32::from(p8))
 133     }
 134
 135     pub fn peek_u24be(&mut self) -> ByteIOResult<u32> {
 136         let mut src: [u8; 3] = [0; 3];
 137         self.peek_buf(&mut src)?;
 138         Ok((u32::from(src[0]) << 16) | (u32::from(src[1]) << 8) | u32::from(src[2]))
 139     }
 140
 141     pub fn read_u32be(&mut self) -> ByteIOResult<u32> {
 142         read_int!(self, u32, 4, to_be)
 143     }
 144
 145     pub fn peek_u32be(&mut self) -> ByteIOResult<u32> {
 146         peek_int!(self, u32, 4, to_be)
 147     }
 148
 149     pub fn read_u64be(&mut self) -> ByteIOResult<u64> {
 150         read_int!(self, u64, 8, to_be)
 151     }
 152
 153     pub fn peek_u64be(&mut self) -> ByteIOResult<u64> {
 154         peek_int!(self, u64, 8, to_be)
 155     }
 156
 157     pub fn read_u16le(&mut self) -> ByteIOResult<u16> {
 158         read_int!(self, u16, 2, to_le)
 159     }
 160
 161     pub fn peek_u16le(&mut self) -> ByteIOResult<u16> {
 162         peek_int!(self, u16, 2, to_le)
 163     }
 164
 165     pub fn read_u24le(&mut self) -> ByteIOResult<u32> {
 166         let p8 = self.read_byte()?;
 167         let p16 = self.read_u16le()?;
 168         Ok((u32::from(p16) << 8) | u32::from(p8))
 169     }
 170
 171     pub fn peek_u24le(&mut self) -> ByteIOResult<u32> {
 172         let mut src: [u8; 3] = [0; 3];
 173         self.peek_buf(&mut src)?;
 174         Ok(u32::from(src[0]) | (u32::from(src[1]) << 8) | (u32::from(src[2]) << 16))
 175     }
 176
 177     pub fn read_u32le(&mut self) -> ByteIOResult<u32> {
 178         read_int!(self, u32, 4, to_le)
 179     }
 180
 181     pub fn peek_u32le(&mut self) -> ByteIOResult<u32> {
 182         peek_int!(self, u32, 4, to_le)
 183     }
 184
 185     pub fn read_u64le(&mut self) -> ByteIOResult<u64> {
 186         read_int!(self, u64, 8, to_le)
 187     }
 188
 189     pub fn peek_u64le(&mut self) -> ByteIOResult<u64> {
 190         peek_int!(self, u64, 8, to_le)
 191     }
 192
 193     pub fn read_skip(&mut self, len: usize) -> ByteIOResult<()> {
 194         if self.io.is_seekable() {
 195             self.io.seek(SeekFrom::Current(len as i64))?;
 196         } else {
 197             let mut ssize = len;
 198             let mut buf : [u8; 16] = [0; 16];
 199             let bref = &mut buf;
 200             while ssize > bref.len() {
 201                 self.io.read_buf(bref)?;
 202                 ssize -= bref.len();
 203             }
 204             while ssize > 0 {
 205                 self.io.read_byte()?;
 206                 ssize -= 1;
 207             }
 208         }
 209         Ok(())
 210     }
 211
 212     pub fn tell(&mut self) -> u64 {
 213         self.io.tell()
 214     }
 215
 216     pub fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
 217         self.io.seek(pos)
 218     }
 219
 220     pub fn is_eof(&self) -> bool {
 221         self.io.is_eof()
 222     }
 223
 224     pub fn size(&mut self) -> i64 {
 225         self.io.size()
 226     }
 227
 228     pub fn left(&mut self) -> i64 {
 229         let size = self.io.size();
 230         if size == -1 { return -1; }
 231         size - (self.io.tell() as i64)
 232     }
 233 }
 234
 235 impl<'a> MemoryReader<'a> {
 236
 237     pub fn new_read(buf: &'a [u8]) -> Self {
 238         MemoryReader { buf, size: buf.len(), pos: 0 }
 239     }
 240
 241     fn real_seek(&mut self, pos: i64) -> ByteIOResult<u64> {
 242         if pos < 0 || (pos as usize) > self.size {
 243             return Err(ByteIOError::WrongRange);
 244         }
 245         self.pos = pos as usize;
 246         Ok(pos as u64)
 247     }
 248 }
 249
 250 impl<'a> ByteIO for MemoryReader<'a> {
 251     fn read_byte(&mut self) -> ByteIOResult<u8> {
 252         if self.is_eof() { return Err(ByteIOError::EOF); }
 253         let res = self.buf[self.pos];
 254         self.pos += 1;
 255         Ok(res)
 256     }
 257
 258     fn peek_byte(&mut self) -> ByteIOResult<u8> {
 259         if self.is_eof() { return Err(ByteIOError::EOF); }
 260         Ok(self.buf[self.pos])
 261     }
 262
 263     fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 264         let copy_size = if self.size - self.pos < buf.len() { self.size } else { buf.len() };
 265         if copy_size == 0 { return Err(ByteIOError::EOF); }
 266         let dst = &mut buf[0..copy_size];
 267         dst.copy_from_slice(&self.buf[self.pos..][..copy_size]);
 268         Ok(copy_size)
 269     }
 270
 271     fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 272         let read_size = self.peek_buf(buf)?;
 273         if read_size < buf.len() { return Err(ByteIOError::EOF); }
 274         self.pos += read_size;
 275         Ok(read_size)
 276     }
 277
 278     fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 279         let read_size = self.peek_buf(buf)?;
 280         self.pos += read_size;
 281         Ok(read_size)
 282     }
 283
 284     #[allow(unused_variables)]
 285     fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
 286         Err(ByteIOError::NotImplemented)
 287     }
 288
 289     fn tell(&mut self) -> u64 {
 290         self.pos as u64
 291     }
 292
 293     fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
 294         let cur_pos  = self.pos  as i64;
 295         let cur_size = self.size as i64;
 296         match pos {
 297             SeekFrom::Start(x)   => self.real_seek(x as i64),
 298             SeekFrom::Current(x) => self.real_seek(cur_pos + x),
 299             SeekFrom::End(x)     => self.real_seek(cur_size + x),
 300         }
 301     }
 302
 303     fn is_eof(&self) -> bool {
 304         self.pos >= self.size
 305     }
 306
 307     fn is_seekable(&mut self) -> bool {
 308         true
 309     }
 310
 311     fn size(&mut self) -> i64 {
 312         self.buf.len() as i64
 313     }
 314 }
 315
 316 impl<'a> FileReader<'a> {
 317
 318     pub fn new_read(file: &'a mut File) -> Self {
 319         FileReader { file, eof : false }
 320     }
 321 }
 322
 323 impl<'a> ByteIO for FileReader<'a> {
 324     fn read_byte(&mut self) -> ByteIOResult<u8> {
 325         let mut byte : [u8; 1] = [0];
 326         let ret = self.file.read(&mut byte);
 327         if ret.is_err() { return Err(ByteIOError::ReadError); }
 328         let sz = ret.unwrap();
 329         if sz == 0 { self.eof = true; return Err(ByteIOError::EOF); }
 330         Ok (byte[0])
 331     }
 332
 333     fn peek_byte(&mut self) -> ByteIOResult<u8> {
 334         let b = self.read_byte()?;
 335         self.seek(SeekFrom::Current(-1))?;
 336         Ok(b)
 337     }
 338
 339     fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 340         let ret = self.file.read(buf);
 341         if ret.is_err() { return Err(ByteIOError::ReadError); }
 342         let sz = ret.unwrap();
 343         if sz < buf.len() { self.eof = true; return Err(ByteIOError::EOF); }
 344         Ok(sz)
 345     }
 346
 347     fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 348         let ret = self.file.read(buf);
 349         if ret.is_err() { return Err(ByteIOError::ReadError); }
 350         let sz = ret.unwrap();
 351         if sz < buf.len() { self.eof = true; }
 352         Ok(sz)
 353     }
 354
 355     fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 356         let size = self.read_buf(buf)?;
 357         self.seek(SeekFrom::Current(-(size as i64)))?;
 358         Ok(size)
 359     }
 360
 361     #[allow(unused_variables)]
 362     fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
 363         Err(ByteIOError::NotImplemented)
 364     }
 365
 366     fn tell(&mut self) -> u64 {
 367         self.file.seek(SeekFrom::Current(0)).unwrap()
 368     }
 369
 370     fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
 371         let res = self.file.seek(pos);
 372         match res {
 373             Ok(r) => Ok(r),
 374             Err(_) => Err(ByteIOError::SeekError),
 375         }
 376     }
 377
 378     fn is_eof(&self) -> bool {
 379         self.eof
 380     }
 381
 382     fn is_seekable(&mut self) -> bool {
 383         true
 384     }
 385
 386     fn size(&mut self) -> i64 {
 387         -1
 388     }
 389 }
 390
 391 #[allow(dead_code)]
 392 pub struct ByteWriter<'a> {
 393     io: &'a mut ByteIO,
 394 }
 395
 396 pub struct MemoryWriter<'a> {
 397     buf:      &'a mut [u8],
 398     size:     usize,
 399     pos:      usize,
 400 }
 401
 402 pub struct FileWriter {
 403     file:     File,
 404 }
 405
 406 impl<'a> ByteWriter<'a> {
 407     pub fn new(io: &'a mut ByteIO) -> Self { ByteWriter { io } }
 408
 409     pub fn write_buf(&mut self, buf: &[u8])  -> ByteIOResult<()> {
 410         self.io.write_buf(buf)
 411     }
 412
 413     pub fn write_byte(&mut self, val: u8) -> ByteIOResult<()> {
 414         let buf: [u8; 1] = [val];
 415         self.io.write_buf(&buf)
 416     }
 417
 418     pub fn write_u16be(&mut self, val: u16) -> ByteIOResult<()> {
 419         let buf: [u8; 2] = [((val >> 8) & 0xFF) as u8, (val & 0xFF) as u8];
 420         self.io.write_buf(&buf)
 421     }
 422
 423     pub fn write_u16le(&mut self, val: u16) -> ByteIOResult<()> {
 424         let buf: [u8; 2] = [(val & 0xFF) as u8, ((val >> 8) & 0xFF) as u8];
 425         self.io.write_buf(&buf)
 426     }
 427
 428     pub fn write_u24be(&mut self, val: u32) -> ByteIOResult<()> {
 429         let buf: [u8; 3] = [((val >> 16) & 0xFF) as u8, ((val >> 8) & 0xFF) as u8, (val & 0xFF) as u8];
 430         self.write_buf(&buf)
 431     }
 432
 433     pub fn write_u24le(&mut self, val: u32) -> ByteIOResult<()> {
 434         let buf: [u8; 3] = [(val & 0xFF) as u8, ((val >> 8) & 0xFF) as u8, ((val >> 16) & 0xFF) as u8];
 435         self.write_buf(&buf)
 436     }
 437
 438     pub fn write_u32be(&mut self, val: u32) -> ByteIOResult<()> {
 439         self.write_u16be(((val >> 16) & 0xFFFF) as u16)?;
 440         self.write_u16be((val & 0xFFFF) as u16)
 441     }
 442
 443     pub fn write_u32le(&mut self, val: u32) -> ByteIOResult<()> {
 444         self.write_u16le((val & 0xFFFF) as u16)?;
 445         self.write_u16le(((val >> 16) & 0xFFFF) as u16)
 446     }
 447
 448     pub fn write_u64be(&mut self, val: u64) -> ByteIOResult<()> {
 449         self.write_u32be((val >> 32) as u32)?;
 450         self.write_u32be(val as u32)
 451     }
 452
 453     pub fn write_u64le(&mut self, val: u64) -> ByteIOResult<()> {
 454         self.write_u32le(val as u32)?;
 455         self.write_u32le((val >> 32) as u32)
 456     }
 457
 458     pub fn tell(&mut self) -> u64 {
 459         self.io.tell()
 460     }
 461
 462     pub fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
 463         self.io.seek(pos)
 464     }
 465
 466     pub fn size_left(&mut self) -> i64 {
 467         let sz = self.io.size();
 468         if sz == -1 { return -1; }
 469         sz - (self.tell() as i64)
 470     }
 471 }
 472
 473 impl<'a> MemoryWriter<'a> {
 474
 475     pub fn new_write(buf: &'a mut [u8]) -> Self {
 476         let len = buf.len();
 477         MemoryWriter { buf, size: len, pos: 0 }
 478     }
 479
 480     fn real_seek(&mut self, pos: i64) -> ByteIOResult<u64> {
 481         if pos < 0 || (pos as usize) > self.size {
 482             return Err(ByteIOError::WrongRange)
 483         }
 484         self.pos = pos as usize;
 485         Ok(pos as u64)
 486     }
 487 }
 488
 489 impl<'a> ByteIO for MemoryWriter<'a> {
 490     #[allow(unused_variables)]
 491     fn read_byte(&mut self) -> ByteIOResult<u8> {
 492         Err(ByteIOError::NotImplemented)
 493     }
 494
 495     #[allow(unused_variables)]
 496     fn peek_byte(&mut self) -> ByteIOResult<u8> {
 497         Err(ByteIOError::NotImplemented)
 498     }
 499
 500     #[allow(unused_variables)]
 501     fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 502         Err(ByteIOError::NotImplemented)
 503     }
 504
 505     #[allow(unused_variables)]
 506     fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 507         Err(ByteIOError::NotImplemented)
 508     }
 509
 510     #[allow(unused_variables)]
 511     fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 512         Err(ByteIOError::NotImplemented)
 513     }
 514
 515     fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
 516         if self.pos + buf.len() > self.size { return Err(ByteIOError::WriteError); }
 517         for i in 0..buf.len() {
 518             self.buf[self.pos + i] = buf[i];
 519         }
 520         self.pos += buf.len();
 521         Ok(())
 522     }
 523
 524     fn tell(&mut self) -> u64 {
 525         self.pos as u64
 526     }
 527
 528     fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
 529         let cur_pos  = self.pos  as i64;
 530         let cur_size = self.size as i64;
 531         match pos {
 532             SeekFrom::Start(x)   => self.real_seek(x as i64),
 533             SeekFrom::Current(x) => self.real_seek(cur_pos + x),
 534             SeekFrom::End(x)     => self.real_seek(cur_size + x),
 535         }
 536     }
 537
 538     fn is_eof(&self) -> bool {
 539         self.pos >= self.size
 540     }
 541
 542     fn is_seekable(&mut self) -> bool {
 543         true
 544     }
 545
 546     fn size(&mut self) -> i64 {
 547         self.buf.len() as i64
 548     }
 549 }
 550
 551 impl FileWriter {
 552     pub fn new_write(file: File) -> Self {
 553         FileWriter { file }
 554     }
 555 }
 556
 557 impl ByteIO for FileWriter {
 558     #[allow(unused_variables)]
 559     fn read_byte(&mut self) -> ByteIOResult<u8> {
 560         Err(ByteIOError::NotImplemented)
 561     }
 562
 563     #[allow(unused_variables)]
 564     fn peek_byte(&mut self) -> ByteIOResult<u8> {
 565         Err(ByteIOError::NotImplemented)
 566     }
 567
 568     #[allow(unused_variables)]
 569     fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 570         Err(ByteIOError::NotImplemented)
 571     }
 572
 573     #[allow(unused_variables)]
 574     fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 575         Err(ByteIOError::NotImplemented)
 576     }
 577
 578     #[allow(unused_variables)]
 579     fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 580         Err(ByteIOError::NotImplemented)
 581     }
 582
 583     fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
 584         match self.file.write_all(buf) {
 585             Ok(()) => Ok(()),
 586             Err(_) => Err(ByteIOError::WriteError),
 587         }
 588     }
 589
 590     fn tell(&mut self) -> u64 {
 591         self.file.seek(SeekFrom::Current(0)).unwrap()
 592     }
 593
 594     fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
 595         let res = self.file.seek(pos);
 596         match res {
 597             Ok(r) => Ok(r),
 598             Err(_) => Err(ByteIOError::SeekError),
 599         }
 600     }
 601
 602     fn is_eof(&self) -> bool {
 603         false
 604     }
 605
 606     fn is_seekable(&mut self) -> bool {
 607         true
 608     }
 609
 610     fn size(&mut self) -> i64 {
 611         -1
 612     }
 613 }
 614
 615 #[cfg(test)]
 616 mod test {
 617     use super::*;
 618     use std::fs::File;
 619
 620     #[test]
 621     fn test_read() {
 622         //const DATA : &'static [u8] = include_bytes!("../../assets/file");
 623         let buf: [u8; 64] = [1; 64];
 624         let mut mr = MemoryReader::new_read(&buf);
 625         let mut reader = ByteReader::new(&mut mr);
 626         assert_eq!(reader.read_byte().unwrap(),  0x01u8);
 627         assert_eq!(reader.read_u16le().unwrap(), 0x0101u16);
 628         assert_eq!(reader.read_u24le().unwrap(), 0x010101u32);
 629         assert_eq!(reader.read_u32le().unwrap(), 0x01010101u32);
 630         assert_eq!(reader.read_u64le().unwrap(), 0x0101010101010101u64);
 631         let mut file = File::open("assets/Misc/MaoMacha.asx").unwrap();
 632         let mut fr = FileReader::new_read(&mut file);
 633         let mut br2 = ByteReader::new(&mut fr);
 634         assert_eq!(br2.read_byte().unwrap(), 0x30);
 635         assert_eq!(br2.read_u24be().unwrap(), 0x26B275);
 636         assert_eq!(br2.read_u24le().unwrap(), 0xCF668E);
 637         assert_eq!(br2.read_u32be().unwrap(), 0x11A6D900);
 638         assert_eq!(br2.read_u32le().unwrap(), 0xCE6200AA);
 639     }
 640     #[test]
 641     fn test_write() {
 642         let mut buf: [u8; 64] = [0; 64];
 643         {
 644             let mut mw = MemoryWriter::new_write(&mut buf);
 645             let mut bw = ByteWriter::new(&mut mw);
 646             bw.write_byte(0x00).unwrap();
 647             bw.write_u16be(0x0102).unwrap();
 648             bw.write_u24be(0x030405).unwrap();
 649             bw.write_u32be(0x06070809).unwrap();
 650             bw.write_u64be(0x0A0B0C0D0E0F1011).unwrap();
 651             bw.write_byte(0x00).unwrap();
 652             bw.write_u16le(0x0201).unwrap();
 653             bw.write_u24le(0x050403).unwrap();
 654             bw.write_u32le(0x09080706).unwrap();
 655             bw.write_u64le(0x11100F0E0D0C0B0A).unwrap();
 656             assert_eq!(bw.size_left(), 28);
 657         }
 658         for i in 0..0x12 {
 659             assert_eq!(buf[(i + 0x00) as usize], i);
 660             assert_eq!(buf[(i + 0x12) as usize], i);
 661         }
 662     }
 663 }