nihav-core/src/io/byteio.rs

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