Refactor sequential read test to use temporary file copying, enhance logging for read speed results, and remove outdated warning from README and App.svelte.

README.md

@@ -4,6 +4,3 @@
 - Store: https://kunkun.sh/store/disk-speed
 
 ![](https://i.imgur.com/8ISVrRe.png)
-
-This extension's read speed is not accurate. Your OS may cache the test data and result in a much higher or lower speed.
-Will be fixed in the future.

speedtest-rs/src/main.rs

@@ -2,6 +2,12 @@ use std::fs::File;
 use std::io::{self, BufReader, Read};
 use std::time::{Instant, Duration};
 use std::path::Path;
+use std::fs;
+
+fn copy_file(src: &Path, dst: &Path) -> io::Result<()> {
+    fs::copy(src, dst)?;
+    Ok(())
+}
 
 fn read_file_speed_test(path: &Path) -> io::Result<(u64, Duration)> {
     let file = File::open(path)?;
@@ -44,21 +50,36 @@ fn format_size(bytes: u64) -> String {
 }
 
 fn main() {
-    let file_path = Path::new("/Volumes/Portable2TB/test.txt");
+    let source_path = Path::new("/Users/hk/Dev/kunkun-extension-repos/disk-speed/test.txt");
+    let copied_path = Path::new("/Users/hk/Dev/kunkun-extension-repos/disk-speed/test_copy.txt");
     
-    println!("Starting disk read speed test on: {}", file_path.display());
+    println!("Copying file to: {}", copied_path.display());
     
-    match read_file_speed_test(file_path) {
+    match copy_file(source_path, copied_path) {
-        Ok((bytes_read, duration)) => {
+        Ok(_) => {
-            let size = format_size(bytes_read);
+            println!("Starting disk read speed test on copied file: {}", copied_path.display());
-            let seconds = duration.as_secs_f64();
-            let speed = bytes_read as f64 / seconds / (1024.0 * 1024.0);
             
-            println!("Read {} in {:.2} seconds", size, seconds);
+            match read_file_speed_test(copied_path) {
-            println!("Read speed: {:.2} MB/s", speed);
+                Ok((bytes_read, duration)) => {
+                    let size = format_size(bytes_read);
+                    let seconds = duration.as_secs_f64();
+                    let speed = bytes_read as f64 / seconds / (1024.0 * 1024.0);
+                    
+                    println!("Read {} in {:.2} seconds", size, seconds);
+                    println!("Read speed: {:.2} MB/s", speed);
+                    
+                    // Clean up the copied file
+                    if let Err(e) = fs::remove_file(copied_path) {
+                        eprintln!("Error removing temporary file: {}", e);
+                    }
+                },
+                Err(e) => {
+                    eprintln!("Error testing read speed: {}", e);
+                }
+            }
         },
         Err(e) => {
-            eprintln!("Error testing read speed: {}", e);
+            eprintln!("Error copying file: {}", e);
         }
     }
 }

speedtest/lib.ts

@@ -1,3 +1,5 @@
+import path from "node:path";
+
 const oneMB = 1024 * 1024;
 export type Progress = { totalMB: number; totalDuration: number };
 
@@ -61,27 +63,33 @@ export async function sequentialReadTest(
     filePath: "",
     rounds: 1,
     deleteAfter: true,
-  }
+  },
+  callback?: (progress: Progress) => void
 ): Promise<Progress> {
   const { filePath, rounds, deleteAfter } = options;
+  const fileContainer = path.dirname(filePath);
+  const filename = path.basename(filePath);
+
   let totalMB = 0;
   let totalDuration = 0;
 
   for (let round = 0; round < rounds; round++) {
-    const file = await Deno.open(filePath, { read: true });
+    const tempFilePath = `${filename}_temp_${Date.now()}`;
-    const reader = file.readable.getReader();
+    const targetFilePath = path.join(fileContainer, tempFilePath);
+    Deno.copyFileSync(filePath, targetFilePath);
+    const file = await Deno.open(targetFilePath, { read: true });
+    const buffer = new Uint8Array(oneMB); // 1MB buffer
     const start = performance.now();
 
-    let readResult;
+    while ((await file.read(buffer)) !== null) {
-    while (!(readResult = await reader.read()).done) {
+      totalMB += 1;
-      totalMB += readResult.value.length / oneMB;
     }
     const roundDuration = (performance.now() - start) / 1000;
     totalDuration += roundDuration;
 
-    await reader.releaseLock();
+    Deno.removeSync(targetFilePath);
+    callback?.({ totalMB, totalDuration });
   }
-
   if (deleteAfter) {
     Deno.removeSync(filePath);
   }

src/App.svelte

@@ -45,7 +45,9 @@
       },
       {}
     );
-
+    command.stderr.on("data", (data) => {
+      console.warn(data);
+    });
     const api = rpcChannel.getAPI();
     const testFileName = "kk-disk-speed-test";
 
@@ -63,11 +65,16 @@
         writeSpeedMBps = totalMB / totalDuration;
       }
     );
-    const readResult = await api.sequentialReadTest({
+    const readResult = await api.sequentialReadTest(
-      filePath: testFilePath,
+      {
-      rounds: 3,
+        filePath: testFilePath,
-      deleteAfter: true,
+        rounds: 3,
-    });
+        deleteAfter: true,
+      },
+      ({ totalMB, totalDuration }) => {
+        readSpeedMBps = totalMB / totalDuration;
+      }
+    );
     writeSpeedMBps = writeResult.totalMB / writeResult.totalDuration;
 
     readSpeedMBps = readResult.totalMB / readResult.totalDuration;
@@ -126,10 +133,6 @@
     <Button disabled={!$targetDir || running} on:click={startSpeedTest}>
       Start Speed Test
     </Button>
-    <small class="text-gray-500">
-      This extension's read speed may be inaccurate. Your OS may cache the test
-      data and result in a higher or lower speed. Will be fixed in the future.
-    </small>
     <div class="grid h-96 w-full grid-cols-2">
       <SpeedGauge
         speedInMBps={writeSpeedMBps}