Skip to content

Commit 1cae0a2

Browse files
00xcandreeaflorescu
authored andcommitted
blk: use new getter methods in tests
Use the new StdIoBackend::inner() and StdIoBackend::inner_mut() methods in tests. This should keep coverage high and act as tests for these methods. Signed-off-by: Carlos López <carlos.lopez@suse.com>
1 parent 2f44a69 commit 1cae0a2

File tree

1 file changed

+29
-29
lines changed

1 file changed

+29
-29
lines changed

crates/devices/virtio-blk/src/stdio_executor.rs

Lines changed: 29 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -602,7 +602,7 @@ mod tests {
602602
GuestAddress(0x200),
603603
);
604604
// Clear the file.
605-
req_exec.inner.write_zeroes_at(0x00, 0x1000).unwrap();
605+
req_exec.inner_mut().write_zeroes_at(0x00, 0x1000).unwrap();
606606

607607
mem.write_slice(&[NON_ZERO_VALUE; 0x200], GuestAddress(0x200))
608608
.unwrap();
@@ -612,34 +612,34 @@ mod tests {
612612
// address and 0x200 bytes from 0x800 address. 0 bytes should've been written in memory.
613613
assert_eq!(req_exec.execute(&mem, &out_req).unwrap(), 0x00);
614614

615-
req_exec.inner.rewind().unwrap();
615+
req_exec.inner().rewind().unwrap();
616616
let mut v = vec![0x00; 0x300];
617-
assert_eq!(req_exec.inner.read(&mut v).unwrap(), 0x300);
617+
assert_eq!(req_exec.inner().read(&mut v).unwrap(), 0x300);
618618
assert_eq!(v, vec![0x00; 0x300]);
619619

620620
// We are at offset 0x300.
621621
v = vec![0x00; 0x200];
622-
assert_eq!(req_exec.inner.read(&mut v).unwrap(), 0x200);
622+
assert_eq!(req_exec.inner().read(&mut v).unwrap(), 0x200);
623623
assert_eq!(v, vec![NON_ZERO_VALUE; 0x200]);
624624

625625
// We are at offset 0x500.
626626
v = vec![0x00; 0x100];
627-
assert_eq!(req_exec.inner.read(&mut v).unwrap(), 0x100);
627+
assert_eq!(req_exec.inner().read(&mut v).unwrap(), 0x100);
628628
assert_eq!(v, vec![0x00; 0x100]);
629629

630630
// We are at offset 0x600.
631631
v = vec![0x00; 0x80];
632-
assert_eq!(req_exec.inner.read(&mut v).unwrap(), 0x80);
632+
assert_eq!(req_exec.inner().read(&mut v).unwrap(), 0x80);
633633
assert_eq!(v, vec![0x00; 0x80]);
634634

635635
// We are at offset 0x680.
636636
v = vec![0x00; 0x100];
637-
assert_eq!(req_exec.inner.read(&mut v).unwrap(), 0x100);
637+
assert_eq!(req_exec.inner().read(&mut v).unwrap(), 0x100);
638638
assert_eq!(v, vec![NON_ZERO_VALUE; 0x100]);
639639

640640
// We are at offset 0x780.
641641
v = vec![0x00; 0x80];
642-
assert_eq!(req_exec.inner.read(&mut v).unwrap(), 0x80);
642+
assert_eq!(req_exec.inner().read(&mut v).unwrap(), 0x80);
643643
assert_eq!(v, vec![0x00; 0x80]);
644644

645645
// Writing 512 bytes to the last sector should be successful.
@@ -835,44 +835,44 @@ mod tests {
835835
// 0 bytes should've been written in memory.
836836
assert_eq!(req_exec.execute(&mem, &wr_zeroes_req).unwrap(), 0x00);
837837

838-
req_exec.inner.rewind().unwrap();
838+
req_exec.inner().rewind().unwrap();
839839
let mut v = vec![0x00; 0x300];
840-
assert_eq!(req_exec.inner.read(&mut v).unwrap(), 0x300);
840+
assert_eq!(req_exec.inner().read(&mut v).unwrap(), 0x300);
841841
assert_eq!(v, vec![0x00; 0x300]);
842842

843843
// We are at offset 0x300.
844844
v = vec![0x00; 0x100];
845-
assert_eq!(req_exec.inner.read(&mut v).unwrap(), 0x100);
845+
assert_eq!(req_exec.inner().read(&mut v).unwrap(), 0x100);
846846
assert_eq!(v, vec![NON_ZERO_VALUE; 0x100]);
847847

848848
// We are at offset 0x400 -> 0x400 bytes should've been zeroed out.
849849
v = vec![0x00; 0x400];
850-
assert_eq!(req_exec.inner.read(&mut v).unwrap(), 0x400);
850+
assert_eq!(req_exec.inner().read(&mut v).unwrap(), 0x400);
851851
assert_eq!(v, vec![0x00; 0x400]);
852852

853853
// We are at offset 0x800.
854854
v = vec![0x00; 0x200];
855-
assert_eq!(req_exec.inner.read(&mut v).unwrap(), 0x200);
855+
assert_eq!(req_exec.inner().read(&mut v).unwrap(), 0x200);
856856
assert_eq!(v, vec![NON_ZERO_VALUE + 1; 0x200]);
857857

858858
// We are at offset 0xA00 -> 0x200 bytes should've been zeroed out.
859859
v = vec![0x00; 0x200];
860-
assert_eq!(req_exec.inner.read(&mut v).unwrap(), 0x200);
860+
assert_eq!(req_exec.inner().read(&mut v).unwrap(), 0x200);
861861
assert_eq!(v, vec![0; 0x200]);
862862

863863
// We are at offset 0xC00.
864864
v = vec![0x00; 0x100];
865-
assert_eq!(req_exec.inner.read(&mut v).unwrap(), 0x100);
865+
assert_eq!(req_exec.inner().read(&mut v).unwrap(), 0x100);
866866
assert_eq!(v, vec![NON_ZERO_VALUE + 1; 0x100]);
867867

868868
// We are at offset 0xD00.
869869
v = vec![0x00; 0x100];
870-
assert_eq!(req_exec.inner.read(&mut v).unwrap(), 0x100);
870+
assert_eq!(req_exec.inner().read(&mut v).unwrap(), 0x100);
871871
assert_eq!(v, vec![0; 0x100]);
872872

873873
// We are at offset 0xE00.
874874
v = vec![0x00; 0x200];
875-
assert_eq!(req_exec.inner.read(&mut v).unwrap(), 0x200);
875+
assert_eq!(req_exec.inner().read(&mut v).unwrap(), 0x200);
876876
assert_eq!(v, vec![NON_ZERO_VALUE; 0x200]);
877877

878878
// Test discard request.
@@ -894,14 +894,14 @@ mod tests {
894894
// 0 bytes should've been written in memory.
895895
assert_eq!(req_exec.execute(&mem, &discard_req).unwrap(), 0x00);
896896

897-
req_exec.inner.seek(SeekFrom::Start(0xE00)).unwrap();
897+
req_exec.inner().seek(SeekFrom::Start(0xE00)).unwrap();
898898
let mut v = vec![0x00; 0x200];
899-
assert_eq!(req_exec.inner.read(&mut v).unwrap(), 0x200);
899+
assert_eq!(req_exec.inner().read(&mut v).unwrap(), 0x200);
900900
assert_eq!(v, vec![0x00; 0x200]);
901901

902902
// Even though we punched a hole at the end of the file, the file size should remain the
903903
// same since FALLOC_FL_PUNCH_HOLE is used with FALLOC_FL_KEEP_SIZE.
904-
assert_eq!(req_exec.inner.metadata().unwrap().len(), 0x1000);
904+
assert_eq!(req_exec.inner().metadata().unwrap().len(), 0x1000);
905905

906906
// Test that write zeroes request with unmap bit set is okay.
907907
let wr_zeroes_req = DiscardWriteZeroes {
@@ -919,30 +919,30 @@ mod tests {
919919
GuestAddress(0x2000),
920920
);
921921

922-
req_exec.inner.seek(SeekFrom::Start(0x800)).unwrap();
922+
req_exec.inner().seek(SeekFrom::Start(0x800)).unwrap();
923923
let mut v = vec![0x00; 0x200];
924-
assert_eq!(req_exec.inner.read(&mut v).unwrap(), 0x200);
924+
assert_eq!(req_exec.inner().read(&mut v).unwrap(), 0x200);
925925
// Data is != 0 before the write zeroes request.
926926
assert_eq!(v, vec![NON_ZERO_VALUE + 1; 0x200]);
927927
// Let's write some data in the file right before and after the fourth sector to confirm
928928
// that those regions won't be zeroed out.
929929
// After the fourth sector:
930930
let v = vec![NON_ZERO_VALUE + 2; 0x200];
931-
assert_eq!(req_exec.inner.write(&v).unwrap(), 0x200);
931+
assert_eq!(req_exec.inner().write(&v).unwrap(), 0x200);
932932
// Before the fourth sector:
933-
req_exec.inner.seek(SeekFrom::Start(0x600)).unwrap();
934-
assert_eq!(req_exec.inner.write(&v).unwrap(), 0x200);
933+
req_exec.inner().seek(SeekFrom::Start(0x600)).unwrap();
934+
assert_eq!(req_exec.inner().write(&v).unwrap(), 0x200);
935935

936936
// 0 bytes should've been written in memory.
937937
assert_eq!(req_exec.execute(&mem, &wr_zeroes_req).unwrap(), 0x00);
938938

939-
req_exec.inner.seek(SeekFrom::Start(0x600)).unwrap();
939+
req_exec.inner().seek(SeekFrom::Start(0x600)).unwrap();
940940
let mut v = vec![0x00; 0x200];
941-
assert_eq!(req_exec.inner.read(&mut v).unwrap(), 0x200);
941+
assert_eq!(req_exec.inner().read(&mut v).unwrap(), 0x200);
942942
assert_eq!(v, vec![NON_ZERO_VALUE + 2; 0x200]);
943-
assert_eq!(req_exec.inner.read(&mut v).unwrap(), 0x200);
943+
assert_eq!(req_exec.inner().read(&mut v).unwrap(), 0x200);
944944
assert_eq!(v, vec![0; 0x200]);
945-
assert_eq!(req_exec.inner.read(&mut v).unwrap(), 0x200);
945+
assert_eq!(req_exec.inner().read(&mut v).unwrap(), 0x200);
946946
assert_eq!(v, vec![NON_ZERO_VALUE + 2; 0x200]);
947947

948948
// VIRTIO_BLK_F_DISCARD not negotiated.

0 commit comments

Comments
 (0)