Add FileInpustStream::available()

Author: dlunch

java_runtime/src/classes/java/io/file_input_stream.rs

@@ -22,6 +22,7 @@ impl FileInputStream {
             methods: vec![
                 JavaMethodProto::new("<init>", "(Ljava/io/File;)V", Self::init, Default::default()),
                 JavaMethodProto::new("read", "([B)I", Self::read, Default::default()),
+                JavaMethodProto::new("available", "()I", Self::available, Default::default()),
                 JavaMethodProto::new("read", "()I", Self::read_byte, Default::default()),
                 JavaMethodProto::new("close", "()V", Self::close, Default::default()),
             ],
@@ -50,6 +51,21 @@ impl FileInputStream {
         Ok(())
     }
 
+    async fn available(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
+        tracing::debug!("java.io.FileInputStream::available({:?})", &this);
+
+        let fd = jvm.get_field(&this, "fd", "Ljava/io/FileDescriptor;").await?;
+        let rust_file = FileDescriptor::file(jvm, fd).await?;
+
+        // TODO get os buffer size
+        let stat = rust_file.metadata().await.unwrap();
+        let tell = rust_file.tell().await.unwrap();
+
+        let available = stat.size - tell;
+
+        Ok(available as _)
+    }
+
     async fn read(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, mut buf: ClassInstanceRef<Array<i8>>) -> Result<i32> {
         tracing::debug!("java.io.FileInputStream::read({:?}, {:?})", &this, &buf);
 

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

@@ -43,3 +43,20 @@ async fn test_file_input_stream_read_int() -> Result<()> {
 
     Ok(())
 }
+
+#[tokio::test]
+async fn test_file_input_stream_available() -> Result<()> {
+    let filesystem = [("test.txt".into(), b"hello world".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 available: i32 = jvm.invoke_virtual(&fis, "available", "()I", ()).await?;
+
+    assert!(available > 0);
+
+    Ok(())
+}

test_utils/src/lib.rs

@@ -123,11 +123,12 @@ impl Runtime for TestRuntime {
 #[derive(Clone)]
 struct DummyFile {
     data: Vec<u8>,
+    pos: FileSize,
 }
 
 impl DummyFile {
     pub fn new(data: Vec<u8>) -> Self {
-        Self { data }
+        Self { data, pos: 0 }
     }
 }
 
@@ -145,20 +146,25 @@ impl File for DummyFile {
         Err(IOError::Unsupported)
     }
 
-    async fn seek(&mut self, _pos: FileSize) -> IOResult<()> {
-        Err(IOError::Unsupported)
+    async fn seek(&mut self, pos: FileSize) -> IOResult<()> {
+        self.pos = pos;
+
+        Ok(())
     }
 
     async fn tell(&self) -> IOResult<FileSize> {
-        Err(IOError::Unsupported)
+        Ok(self.pos as _)
     }
 
     async fn set_len(&mut self, _len: FileSize) -> IOResult<()> {
         Err(IOError::Unsupported)
     }
 
     async fn metadata(&self) -> IOResult<FileStat> {
-        Err(IOError::Unsupported)
+        Ok(FileStat {
+            size: self.data.len() as FileSize,
+            r#type: FileType::File,
+        })
     }
 }