Share DummyFile state between clones in test runtime

Runtime::get_file hands out cloned handles, so reads through fresh
handles never advanced the file position. Share pos like the
production File impls and make read honor it instead of consuming
the buffer.

Author: dlunch

java_runtime/tests/classes/java/io/test_file_input_stream.rs

@@ -60,3 +60,42 @@ async fn test_file_input_stream_available() -> Result<()> {
 
     Ok(())
 }
+
+#[tokio::test]
+async fn test_file_input_stream_sequential_read() -> Result<()> {
+    let filesystem = [("test.txt".into(), b"hello".to_vec())];
+    let jvm = test_jvm_filesystem(filesystem.into_iter().collect()).await?;
+
+    let file = JavaLangString::from_rust_string(&jvm, "test.txt").await?;
+
+    let java_file = jvm.new_class("java/io/File", "(Ljava/lang/String;)V", (file,)).await?;
+    let fis = jvm.new_class("java/io/FileInputStream", "(Ljava/io/File;)V", (java_file,)).await?;
+
+    let mut reads = vec![];
+    for _ in 0..6 {
+        reads.push(jvm.invoke_virtual::<_, i32>(&fis, "read", "()I", ()).await?);
+    }
+
+    assert_eq!(reads, vec![104, 101, 108, 108, 111, -1]);
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_file_input_stream_skip_past_eof() -> Result<()> {
+    let filesystem = [("test.txt".into(), b"hello".to_vec())];
+    let jvm = test_jvm_filesystem(filesystem.into_iter().collect()).await?;
+
+    let file = JavaLangString::from_rust_string(&jvm, "test.txt").await?;
+
+    let java_file = jvm.new_class("java/io/File", "(Ljava/lang/String;)V", (file,)).await?;
+    let fis = jvm.new_class("java/io/FileInputStream", "(Ljava/io/File;)V", (java_file,)).await?;
+
+    let skipped: i64 = jvm.invoke_virtual(&fis, "skip", "(J)J", (10i64,)).await?;
+    assert_eq!(skipped, 5);
+
+    let read: i32 = jvm.invoke_virtual(&fis, "read", "()I", ()).await?;
+    assert_eq!(read, -1);
+
+    Ok(())
+}

test_utils/src/lib.rs

@@ -158,21 +158,28 @@ impl Runtime for TestRuntime {
 #[derive(Clone)]
 struct DummyFile {
     data: Vec<u8>,
-    pos: FileSize,
+    // shared between clones, as Runtime::get_file hands out cloned handles to the same file
+    pos: Arc<Mutex<FileSize>>,
 }
 
 impl DummyFile {
     pub fn new(data: Vec<u8>) -> Self {
-        Self { data, pos: 0 }
+        Self {
+            data,
+            pos: Arc::new(Mutex::new(0)),
+        }
     }
 }
 
 #[async_trait::async_trait]
 impl File for DummyFile {
     async fn read(&mut self, buf: &mut [u8]) -> IOResult<usize> {
-        let len = min(buf.len(), self.data.len());
-        buf[..len].copy_from_slice(&self.data[..len]);
-        self.data = self.data[len..].to_vec();
+        let mut pos = self.pos.lock().unwrap();
+
+        let remaining = &self.data[min(*pos as usize, self.data.len())..];
+        let len = min(buf.len(), remaining.len());
+        buf[..len].copy_from_slice(&remaining[..len]);
+        *pos += len as FileSize;
 
         Ok(len)
     }
@@ -182,13 +189,13 @@ impl File for DummyFile {
     }
 
     async fn seek(&mut self, pos: FileSize) -> IOResult<()> {
-        self.pos = pos;
+        *self.pos.lock().unwrap() = pos;
 
         Ok(())
     }
 
     async fn tell(&self) -> IOResult<FileSize> {
-        Ok(self.pos as _)
+        Ok(*self.pos.lock().unwrap())
     }
 
     async fn set_len(&mut self, _len: FileSize) -> IOResult<()> {