feat: Replace random files with demo files

hash_longterm.py

@@ -24,21 +24,17 @@ if __name__ == "__main__":
     arguments: dict = dict(arg.split('=') for arg in sys.argv[1:])
 
     drive_letter: chr = None
-    file_amount: int = 10
-    wait_time: int = 21600  # 6 hours (4 times a day)
+    wait_time: int = 60 * 60  # every hour
     format_drive: bool = False
-    threshold: int = 2
-    max_iterations: int = 20  # max 5 days (after that change should be visible)
-    max_memory: int = 1_024
+    threshold: int = 6
+    max_iterations: int = 60 * 60 * 24 * 7  # 1 week
+    max_memory: int = 256
 
     for argument in arguments.keys():
         match(argument):
             case("drive_letter"):
                 drive_letter = arguments.get("drive_letter")
 
-            case("file_amount"):
-                file_amount = int(arguments.get("file_amount"))
-
             case("wait_time"):
                 wait_time = int(arguments.get("wait_time"))
 
@@ -72,17 +68,13 @@ if __name__ == "__main__":
 
     # write random data to the disk
     print(colored(log("[Hash-Longtermstudy] Starting the hash run!"), "light_blue"))
-    drive_handle.generate_random_data(file_amount, 10_000)
+    drive_handle.copy_demo_files()
     print(colored(log("[Hash-Longtermstudy] Waiting 120s for the OS to flush the write buffer."), "cyan"))
     time.sleep(120)
     # create hash
     print(colored(log(f"[Hash-Longtermstudy] The hash prior to the deletion is {drive_handle.generate_hash()}"), "light_blue"))
     # delete data
-    drive_handle.delete_file(f"{drive_handle.get_path()}transsd-random-1")
-    drive_handle.delete_file(f"{drive_handle.get_path()}transsd-random-2")
-    drive_handle.delete_file(f"{drive_handle.get_path()}transsd-random-3")
-    drive_handle.delete_file(f"{drive_handle.get_path()}transsd-random-4")
-    drive_handle.delete_file(f"{drive_handle.get_path()}transsd-random-5")
+    drive_handle.remove_demo_files()
     # set drive to read only
     drive_handle.set_read_only(True)
     # repeadetly create the hash

main.py

@@ -18,7 +18,7 @@ if __name__ == "__main__":
     slack_test: bool = True
     drive_letter: chr = ''
     format_drive: bool = False
-    check_cluster_overlap: bool = True
+    check_cluster_overlap: bool = False
     max_memory: int = 1_024  # 1 GB
 
     for argument in arguments.keys():

requirements.txt

@@ -4,3 +4,4 @@ pywin32==306
 termcolor==2.4.0
 progress==1.6
 pyuac==0.0.3
+setuptools==70.0.0
\ No newline at end of file

src/drive_handle.py

-from hashlib import sha1
-import os
-import random
-import psutil
 import ctypes
+import os
+import shutil
 import subprocess
-from termcolor import colored
+from distutils.dir_util import copy_tree
+from hashlib import sha1
+
+import psutil
 from progress.spinner import Spinner
+from termcolor import colored
 
 
 class DriveHandle:
@@ -130,18 +132,13 @@ class DriveHandle:
             file_descriptor.write(symbol.encode() * file_size)
         print(colored("[DriveHandle] Completed writing the overwrite file.", "light_grey"))
 
-    def generate_random_data(self, amount: int, max_file_size: int) -> None:
-        print(colored(f"[DriveHandle] Writing {amount} random files to the disk.", "light_grey"))
-        for file_number in range(1, amount + 1):
-            print(colored(f"[DriveHandle] Writing file {self._drive_letter}:\\transsd-random-{file_number}.", "light_grey"))
-            file_size = random.randint(8, max_file_size)
-            written_size = 0
-            while written_size < file_size:
-                with open(f"{self._drive_letter}:\\transsd-random-{file_number}", "wt") as file:
-                    hex_value = random.randint(65, 122)
-                    hex_size = random.randint(1, 10)
-                    file.write(chr(hex_value) * hex_size)
-                    written_size += hex_size
+    def copy_demo_files(self) -> None:
+        working_dir = os.path.abspath(os.path.join((os.path.dirname(os.path.abspath(__file__))), os.pardir))
+        copy_tree(f'{working_dir}\\demo', f'{self._drive_letter}:\\demo')
+
+    def remove_demo_files(self) -> None:
+        if (os.path.isdir(f'{self._drive_letter}:\\demo')):
+            shutil.rmtree(f'{self._drive_letter}:\\demo')
 
     def delete_file(self, path: str) -> None:
         print(colored(f"[DriveHandle] Deleting file {path}.", "light_grey"))

src/tests/hash_test.py

@@ -17,18 +17,13 @@ class HashTest(DecisionTest):
 
     def determine_SSD_indication(self) -> float:
         print(colored("[HashTest] Running the hash test!", 'light_blue'))
-        print(colored("[HashTest] Generating random files.", 'light_grey'))
-        self._drive_handle.generate_random_data(10, 10_000)
+        print(colored("[HashTest] Copying the demo files.", 'light_grey'))
+        self._drive_handle.copy_demo_files()
         print(colored("[HashTest] Waiting 120s for the OS to flush the write buffer.", "light_grey"))
         time.sleep(120)
         print(colored(f"[HashTest] The current hash of the drive is equal to {self._drive_handle.generate_hash()}", "yellow"))
-        print(colored("[HashTest] Deleting some files.", 'light_grey'))
-        self._drive_handle.delete_file(f"{self._drive_handle.get_path()}transsd-random-1")
-        self._drive_handle.delete_file(f"{self._drive_handle.get_path()}transsd-random-2")
-        self._drive_handle.delete_file(f"{self._drive_handle.get_path()}transsd-random-3")
-        self._drive_handle.delete_file(f"{self._drive_handle.get_path()}transsd-random-4")
-        self._drive_handle.delete_file(f"{self._drive_handle.get_path()}transsd-random-5")
-        print(colored("[HashTest] Deleted files 1 to 5.", 'light_grey'))
+        print(colored("[HashTest] Deleting the demo files.", 'light_grey'))
+        self._drive_handle.remove_demo_files()
         self._drive_handle.set_read_only(True)
         detected_wear_levelling: bool = False
         prior_hash: str = None
@@ -50,13 +45,13 @@ class HashTest(DecisionTest):
             else:
                 print(colored(f"[HashTest] The threshold of 2 changes before measuring is not exceeded yet. Currently at iteration {iteration}. Continuing...", "green"))
             prior_hash = current_hash
-            if iteration >= 20:  # 5 days of observation at max
-                print(colored(f"[HashTest] Reached iteration {iteration} (max iterations was set to 20). Stopping the test.", "light_blue"))
+            if iteration >= 168:  # 7 days of observation at max
+                print(colored(f"[HashTest] Reached iteration {iteration} (max iterations was set to 168). Stopping the test.", "light_blue"))
                 detected_wear_levelling = False
                 break
 
-            print(colored("[HashTest] Waiting 6h until generating the next hash.", "light_grey"))
-            time.sleep(60 * 60 * 6)
+            print(colored("[HashTest] Waiting 1h until generating the next hash.", "light_grey"))
+            time.sleep(60 * 60)
 
         # release drive
         self._drive_handle.set_read_only(False)