Implemented TEST command.

Author: mkrueger

crates/dizbase/src/file_base/mod.rs

@@ -140,7 +140,6 @@ impl FileBase {
         let header = if let Some(index) = self.name_map.get(&file_name).clone() {
             if self.file_headers[*index].metadata_offset() == u64::MAX {
                 let res = self.create_header(*index, &path);
-                self.save()?;
                 return res;
             }
             &self.file_headers[*index]
@@ -204,25 +203,28 @@ impl FileBase {
 
     pub fn get_hash(path: &Path) -> crate::Result<u64> {
         let data = fs::read(&path)?;
-        Ok(XxHash3_64::oneshot(&data))
+        let hash = XxHash3_64::oneshot(&data);
+        Ok(hash)
     }
 
     fn create_header(&mut self, index: usize, path: &Path) -> crate::Result<Vec<MetadataHeader>> {
         match scan_file(&path) {
             Ok(meta_data) => {
                 let metadata_file_name = self.meta_data_path.with_extension(extensions::FILE_METADATA);
+                let md_len = if let Ok(md) = fs::metadata(&metadata_file_name) { md.len() } else { 0 };
                 let Ok(mut file) = OpenOptions::new().append(true).create(true).open(&metadata_file_name) else {
                     log::error!("Error opening metadata file: {}", metadata_file_name.display());
                     return Err(FileBaseError::CantOpenMetadata.into());
                 };
-                self.file_headers[index].metadata_offset = file.seek(std::io::SeekFrom::Current(0))?;
+                self.file_headers[index].metadata_offset = md_len;
                 file.write(&[meta_data.len() as u8])?;
                 for meta in &meta_data {
                     file.write(&[meta.get_type().to_data()])?;
                     let len = meta.data.len() as u32;
                     file.write(&len.to_le_bytes())?;
                     file.write(&meta.data)?;
                 }
+                self.save()?;
                 Ok(meta_data)
             }
             Err(err) => {
@@ -265,7 +267,7 @@ impl FileBase {
         for _ in 0..size {
             reader.read_exact(&mut data)?;
             let metadata_type = MetadataType::from_data(data[0]);
-            let data_len = u32::from_le_bytes(data[1..].try_into().unwrap()) as usize;
+            let data_len = u32::from_le_bytes(data[1..5].try_into().unwrap()) as usize;
 
             let mut data = vec![0; data_len];
             reader.read_exact(&mut data)?;

crates/dizbase/src/file_base_scanner/mod.rs

@@ -9,26 +9,26 @@ use icy_sauce::SauceInformation;
 use unrar::Archive;
 
 use crate::file_base::{
-    FileBase, FileBaseError,
+    FileBase,
     metadata::{MetadataHeader, MetadataType},
 };
 pub mod repack;
 
 pub mod bbstro_fingerprint;
 
 pub fn scan_file(path: &Path) -> crate::Result<Vec<MetadataHeader>> {
-    let Some(extension) = path.extension() else {
-        return Err(FileBaseError::NoExtension.into());
-    };
-    let extension = extension.to_string_lossy().to_uppercase();
-
     let mut info = Vec::new();
     let hash = FileBase::get_hash(path)?;
     info.push(MetadataHeader {
         metadata_type: MetadataType::Hash,
         data: hash.to_le_bytes().to_vec(),
     });
 
+    let Some(extension) = path.extension() else {
+        return Ok(info);
+    };
+    let extension = extension.to_string_lossy().to_uppercase();
+
     match extension.as_str() {
         "ZIP" => scan_zip(info, &path),
         "LHA" | "LZH" => scan_lha(info, path),

crates/icbsetup/data/new_bbs/help/hlptest.icy

@@ -26,7 +26,7 @@ impl QwkSettings {
                 cfg_entry_text!("qwk_bbs_city_and_state", label_width, 25, qwk_settings, bbs_city_and_state, lock),
                 cfg_entry_text!("qwk_bbs_phone_number", label_width, 25, qwk_settings, bbs_phone_number, lock),
                 cfg_entry_text!("qwk_bbs_sysop_name", label_width, 25, qwk_settings, bbs_sysop_name, lock),
-                cfg_entry_text!("qwk_bbs_id", label_width, 25, qwk_settings, bbs_id, lock),
+                cfg_entry_text!("qwk_bbs_id", label_width, 8, qwk_settings, bbs_id, lock),
                 ConfigEntry::Separator,
                 ConfigEntry::Label(get_text("qwk_files_label")),
                 cfg_entry_path!("qwk_welcome_screen", label_width, qwk_settings, welcome_screen, lock),

crates/icbsetup/src/tabs/general/msg_networking/qwk.rs

@@ -1,8 +1,110 @@
-use crate::{Res, icy_board::state::IcyBoardState};
+use dizbase::file_base::{FileBase, metadata::MetadataType};
+use regex::Regex;
+
+use crate::{
+    Res,
+    icy_board::{
+        commands::CommandType,
+        icb_text::IceText,
+        state::{
+            IcyBoardState,
+            functions::{MASK_ASCII, display_flags},
+        },
+    },
+};
 
 impl IcyBoardState {
     pub async fn test_file_command(&mut self) -> Res<()> {
-        // TODO
+        if self.session.current_conference.directories.is_none() || self.session.current_conference.directories.as_ref().unwrap().is_empty() {
+            self.display_text(IceText::NoDirectoriesAvailable, display_flags::NEWLINE | display_flags::LFBEFORE)
+                .await?;
+            return Ok(());
+        }
+        let mut found = false;
+
+        while !found {
+            let search_pattern = if let Some(token) = self.session.tokens.pop_front() {
+                token
+            } else {
+                self.input_field(
+                    IceText::TestFileName,
+                    40,
+                    &MASK_ASCII,
+                    CommandType::TestFile.get_help(),
+                    None,
+                    display_flags::NEWLINE | display_flags::UPCASE | display_flags::LFBEFORE | display_flags::HIGHASCII,
+                )
+                .await?
+            };
+            if search_pattern.is_empty() {
+                return Ok(());
+            }
+
+            let Ok(search_regex) = Regex::new(&search_pattern) else {
+                self.display_text(IceText::PunctuationError, display_flags::NEWLINE | display_flags::LFBEFORE)
+                    .await?;
+                return Ok(());
+            };
+
+            self.session.push_tokens(&"A");
+            let dir_numbers = self.get_dir_numbers().await?;
+            self.session.disp_options.no_change();
+            for (_num, _desc, path, metadata) in dir_numbers.numbers {
+                let Ok(base) = self.get_filebase(&path, &metadata).await else {
+                    continue;
+                };
+                let header_count = base.lock().await.len();
+                for file in 0..header_count {
+                    let file_name = base.lock().await[file].name().to_string();
+                    if !search_regex.is_match(&file_name) {
+                        continue;
+                    }
+                    found = true;
+                    self.session.op_text = file_name;
+                    self.display_text(IceText::VerifyingFile, display_flags::DEFAULT).await?;
+                    let full_path = path.join(&self.session.op_text);
+                    if !full_path.exists() {
+                        log::error!("TEST: File not found: {:?}", full_path);
+                        self.display_text(IceText::Failed, display_flags::NEWLINE).await?;
+                        continue;
+                    }
+
+                    let hash = base.lock().await.read_metadata(&full_path)?;
+                    let mut found_metadata = false;
+                    for data in hash {
+                        if data.metadata_type == MetadataType::Hash {
+                            found_metadata = true;
+                            let hash = u64::from_le_bytes(data.data.as_slice().try_into().unwrap());
+                            let current_hash = FileBase::get_hash(&full_path)?;
+                            if hash == current_hash {
+                                self.display_text(IceText::Passed, display_flags::NEWLINE).await?;
+                            } else {
+                                log::error!(
+                                    "TEST: File hash invalid: {:?} {:08X} != {:08X}",
+                                    full_path,
+                                    hash,
+                                    FileBase::get_hash(&full_path)?
+                                );
+                                self.display_text(IceText::Failed, display_flags::NEWLINE).await?;
+                            }
+                            break;
+                        }
+                    }
+                    if !found_metadata {
+                        self.display_text(IceText::Passed, display_flags::NEWLINE).await?;
+                    }
+                }
+
+                if self.session.disp_options.abort_printout {
+                    break;
+                }
+            }
+
+            if !found {
+                self.session.op_text = search_pattern;
+                self.display_text(IceText::NotFoundOnDisk, display_flags::NEWLINE).await?;
+            }
+        }
         Ok(())
     }
 }

crates/icy_board_engine/src/icy_board/state/user_commands/pcb/test_file.rs

@@ -89,7 +89,7 @@ If something is missing just let me know.
 | BU/UB  | Batch Upload | 0% | 
 | RM  | Read Message | 0% | Read remembered message
 | SELECT | Select Conference | 99% | Changes were needed due to message areas [^1]
-| TEST | Test File | 0% | 
+| TEST | Test File | 💯 | Slight improvements - search for pattern
 
 [^1]: PCBTEXT #586 changed to `Conference`,
   #587 changed to `#   Name                                                   Flags`