Added runtime req for iperf3

.woodpecker.yml

@@ -2,12 +2,15 @@ pipeline:
   test_build:
     image: rust:1.62
     commands:
-      - cargo build
+      - "cargo build"
 
   build_release:
     image: rust:1.62
     commands:
-      - cargo build --release
+      - "cargo install cargo-deb cargo-generate-rpm"
+      - "cargo build --release"
+      - "cargo deb"
+      - "cargo generate-rpm"
       - "mv target/release/bgbench target/release/bgbench-${CI_COMMIT_TAG}-linux-x86_64"
     when:
       event: tag
@@ -20,6 +23,8 @@ pipeline:
       base_url: https://git.metaunix.net
       files:
         - "target/release/*${CI_COMMIT_TAG}-linux-x86_64"
+        - "target/debian/hardware-tests*.deb"
+        - "target/generate-rpm/hardware-tests*.rpm"
       title: "${CI_COMMIT_TAG}"
     when:
       event: tag

Cargo.toml

@@ -1,14 +1,27 @@
 [package]
 name = "hardware-tests"
-version = "0.2.1"
+description = "Bit Goblin PC hardware test suite."
+version = "0.4.0"
 edition = "2021"
+readme = "README.md"
+license = "BSD 2-Clause"
+authors = ["Gregory Ballantine <gballantine@bitgoblin.tech>"]
 
 [[bin]]
 name = "bgbench"
 path = "src/main.rs"
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
 [dependencies]
-chrono = "0.4.20"
+chrono = "0.4"
-clap = { version = "3.2.16", features = ["derive"] }
+clap = { version = "3.2", features = ["derive"] }
+sysinfo = "0.25"
+
+[package.metadata.deb]
+depends = "fio"
+
+[package.metadata.generate-rpm]
+assets = [
+	{ source = "target/release/bgbench", dest = "/usr/bin/bgbench", mode = "755" },
+]
+[package.metadata.generate-rpm.requires]
+fio = "*"

README.md

@@ -1,6 +1,6 @@
 # Bit Goblin Hardware Tests
 
-Scripts used for testing hardware in Bit Goblin's videos.
+Benchmarking suite used for testing hardware in Bit Goblin's videos.
 
 ## Download & Installation
 
@@ -8,9 +8,17 @@ Check out the [Releases page](https://git.metaunix.net/BitGoblin/hardware-tests/
 
 Currently there is no installation method other than downloading the provided release binaries. In the future I want to build Linux package repositories for this, and have a Windows installer.
 
+## Running
+
+Simply run the tool with `./bgbench` and you'll be presented with the available subcommands.
+
+### Runtime requirements:
+* `disk` - requires `fio`.
+* `network bandwidth` - requires `iperf3`
+
 ## Building
 
-The easiest way to build the program is using the official Rust image from Docker Hub, for which there's a wrapper script at `bin/docker-build.sh` that can be used to build the test programs. These will be available under `target/debug/`.
+The easiest way to build the program is using the official Rust image from Docker Hub, for which there's a wrapper script at `bin/docker-build.sh` that can be used to build the test program. These will be available under `target/debug/`. Else you can just run a `cargo build` to compile the program.
 
 ## License
 

src/benchmarks/disk.rs

@@ -0,0 +1,109 @@
+use std::process::Command;
+
+// test disk sequential read speeds w/ fio
+pub fn disk_read_seq_test(tempfile: &str, size: &u8) {
+    // run the fio command
+    let output = Command::new("fio")
+        .arg("--name=TEST")
+        .arg(format!("--filename={}", tempfile))
+        .arg("--rw=read")
+        .arg("--size=2g")
+        .arg(format!("--io_size={}g", size))
+        .arg("--blocksize=1024k")
+        .arg("--ioengine=libaio")
+        .arg("--fsync=10000")
+        .arg("--iodepth=32")
+        .arg("--direct=1")
+        .arg("--numjobs=1")
+        .arg("--runtime=60")
+        .arg("--group_reporting")
+        .output()
+        .expect("Failed to execute command");
+
+    // check that the command succeeded
+    assert!(output.status.success());
+
+    // print the test's output
+    println!("{}", String::from_utf8_lossy(&output.stdout));
+}
+
+// test disk 4K random read speeds w/ fio
+pub fn disk_read_rand_test(tempfile: &str, size: &u8) {
+    // run the fio command
+    let output = Command::new("fio")
+        .arg("--name=TEST")
+        .arg(format!("--filename={}", tempfile))
+        .arg("--rw=randread")
+        .arg("--size=2g")
+        .arg(format!("--io_size={}g", size))
+        .arg("--blocksize=4k")
+        .arg("--ioengine=libaio")
+        .arg("--fsync=1")
+        .arg("--iodepth=1")
+        .arg("--direct=1")
+        .arg("--numjobs=32")
+        .arg("--runtime=60")
+        .arg("--group_reporting")
+        .output()
+        .expect("Failed to execute command");
+
+    // check that the command succeeded
+    assert!(output.status.success());
+
+    // print the test's output
+    println!("{}", String::from_utf8_lossy(&output.stdout));
+}
+
+// test sequential disk write speeds w/ fio
+pub fn disk_write_seq_test(tempfile: &str, size: &u8) {
+    // run the fio command
+    let output = Command::new("fio")
+        .arg("--name=TEST")
+        .arg(format!("--filename={}", tempfile))
+        .arg("--rw=write")
+        .arg("--size=2g")
+        .arg(format!("--io_size={}g", size))
+        .arg("--blocksize=1024k")
+        .arg("--ioengine=libaio")
+        .arg("--fsync=10000")
+        .arg("--iodepth=32")
+        .arg("--direct=1")
+        .arg("--numjobs=1")
+        .arg("--runtime=60")
+        .arg("--group_reporting")
+        .output()
+        .expect("Failed to execute command");
+
+    // check that the command succeeded
+    assert!(output.status.success());
+
+    // print the test's output
+    println!("{}", String::from_utf8_lossy(&output.stdout));
+}
+
+// test random 4K disk write speeds w/ fio
+pub fn disk_write_rand_test(tempfile: &str, size: &u8) {
+    // run the fio command
+    let output = Command::new("fio")
+        .arg("--name=TEST")
+        .arg(format!("--filename={}", tempfile))
+        .arg("--rw=randrw")
+        .arg("--size=2g")
+        .arg(format!("--io_size={}g", size))
+        .arg("--blocksize=4k")
+        .arg("--ioengine=libaio")
+        .arg("--fsync=1")
+        .arg("--iodepth=1")
+        .arg("--direct=1")
+        .arg("--numjobs=32")
+        .arg("--runtime=60")
+        .arg("--group_reporting")
+        .output()
+        .expect("Failed to execute command");
+
+    // check that the command succeeded
+    assert!(output.status.success());
+
+    // print the test's output
+    println!("{}", String::from_utf8_lossy(&output.stdout));
+}

src/benchmarks/games.rs

@@ -0,0 +1,36 @@
+use std::process::Command;
+
+pub fn run_civ6_ai_benchmark() {
+    // make sure CS:GO is installed via Steam
+    download_game_steam(289070);
+}
+
+// run the CS:GO benchmark (using benchmark file from PTS)
+pub fn run_csgo_benchmark() {
+    // make sure CS:GO is installed via Steam
+    download_game_steam(730);
+}
+
+pub fn run_demd_benchmark() {
+    // make sure CS:GO is installed via Steam
+    download_game_steam(337000);
+}
+
+fn download_game_steam(game_id: u32) {
+    let mut steam_path = "steam";
+    if cfg!(windows) {
+        steam_path = "C:\\Program Files (x86)\\Steam\\steam.exe";
+    }
+
+    // first we need to make sure CS:GO is installed via Steam
+    let install_output = Command::new(steam_path)
+        .arg(format!("steam://install/{}", game_id))
+        .output()
+        .expect("Failed to execute command");
+
+    // check that the command succeeded
+    assert!(install_output.status.success());
+
+    // print the test's output
+    println!("{}", String::from_utf8_lossy(&install_output.stdout));
+}

src/benchmarks/mod.rs

@@ -1,2 +1,3 @@
 pub mod disk;
+pub mod games;
 pub mod network;

src/benchmarks/network.rs

@@ -0,0 +1,90 @@
+use std::process;
+
+use crate::text;
+
+// ping a host
+pub fn latency_test(address: &str, count: &u16, interval: &u16) {
+    println!("Pinging host {}, {} times.", address, count);
+
+    // if we're on Windows we need to use the -n flag for ping counts
+    let mut count_arg = "-c";
+    if cfg!(windows) {
+        count_arg = "-n";
+    }
+
+    // convert the ping interval to seconds
+    let interval_secs = *interval as f64 / 1000 as f64;
+
+    // run the ping command
+    let output = process::Command::new("ping")
+        .arg(address)
+        .arg(count_arg)
+        .arg(format!("{}", count))
+        .arg("-i")
+        .arg(format!("{}", interval_secs))
+        .output()
+        .expect("Failed to execute command");
+
+    // check that the command succeeded
+    assert!(output.status.success());
+
+    // grab the ping results from stdout
+    let results_raw = &String::from_utf8_lossy(&output.stdout);
+    let results = text::format::trim_output(results_raw, 4);
+    for line in results {
+        println!("{}", line);
+    }
+}
+
+// network jitter test
+pub fn jitter_test(address: &str, count: &u16, interval: &u16) {
+    println!("Pinging host {}, {} times to determine network jitter.", address, count);
+
+    // if we're on Windows we need to use the -n flag for ping counts
+    let mut count_arg = "-c";
+    if cfg!(windows) {
+        count_arg = "-n";
+    }
+
+    // convert the ping interval to seconds
+    let interval_secs = *interval as f64 / 1000 as f64;
+
+    // run the ping command
+    let output = process::Command::new("ping")
+        .arg(address)
+        .arg(count_arg)
+        .arg(format!("{}", count))
+        .arg("-i")
+        .arg(format!("{}", interval_secs))
+        .output()
+        .expect("Failed to execute command");
+
+    // check that the command succeeded
+    assert!(output.status.success());
+
+    // grab the ping results from stdout
+    let results_raw = &String::from_utf8_lossy(&output.stdout);
+    let results = text::format::trim_output(results_raw, 4);
+    for line in results {
+        println!("{}", line);
+    }
+}
+
+// timed file copy test to guage bandwidth speeds
+pub fn bandwidth_test(host: &str) {
+    println!("Testing network bandwidth using iperf; connecting to {}.", host);
+    println!("{}", host);
+
+    let output = process::Command::new("iperf3")
+        .arg("-c")
+        .arg(host)
+        .output()
+        .expect("Failed to execute command");
+
+    // check that the command succeeded
+    assert!(output.status.success());
+
+    // grab and print the command's results
+    let results_raw = &String::from_utf8_lossy(&output.stdout);
+    println!("{}", results_raw);
+}

src/main.rs

@@ -1,6 +1,8 @@
-mod tests;
+mod benchmarks;
+mod stress;
+mod text;
 
-use clap::{Parser, Subcommand};
+use clap::{Args, Parser, Subcommand};
 
 #[derive(Parser)]
 #[clap(name = "Bit Goblin Benchmark", author, version, about = "Bit Goblin's hardware benchmarking tool.", long_about = None)]
@@ -8,41 +10,109 @@ use clap::{Parser, Subcommand};
 struct Cli {
     #[clap(subcommand)]
     command: Commands,
+
+    #[clap(short = 'l', long, default_value_t = 1, help = "Number of times to run test. Default = 1", global = true)]
+    loopcount: u8,
 }
 
 #[derive(Subcommand)]
 enum Commands {
-    // disk tests subcommand
+    // CPU benchmarks subcommand
+    #[clap(name = "cpu", about = "CPU benchmarks and stress tests.")]
+    Cpu(Cpu),
+    // disk benchmarks subcommand
     #[clap(name = "disk", about = "Hard drive and SSD benchmarks.")]
     Disk(Disk),
-    // network tests subcommand
+    // games benchmarks subcommand
+    #[clap(name = "games", about = "Benchmark your system with games.")]
+    Games(Games),
+    // network benchmarks subcommand
     #[clap(name = "network", about = "Test various aspects of your network.")]
     Net(Net),
 }
 
-#[derive(Parser)]
+#[derive(Args)]
+struct Cpu {
+    #[clap(subcommand)]
+    cpu_commands: CpuCommands,
+}
+
+#[derive(Subcommand)]
+enum CpuCommands {
+    // CPU stress test subcommand
+    #[clap(name = "stress", about = "Stress test the CPU with math!")]
+    StressTest {
+        #[clap(short = 'r', long, default_value_t = 5, help = "Length of time (in minutes) to run the stress test. Defaults to 5")]
+        runtime: u16,
+        #[clap(short = 't', long, default_value_t = 0, help = "Number of threads to use; defaults to CPU's max thread count. Defaults to 0 (automatic)")]
+        threads: usize,
+    },
+}
+
+#[derive(Args)]
 struct Disk {
-    #[structopt(subcommand)]
+    #[clap(subcommand)]
     disk_commands: DiskCommands,
 }
 
 #[derive(Subcommand)]
 enum DiskCommands {
-    // disk read subcommand
+    // sequential disk read subcommand
-    #[clap(name = "read-test", about = "Read from /dev/zero to determine sequential disk read speeds.")]
+    #[clap(name = "read_seq", about = "Sequential disk read speed test.")]
-    ReadTest {
+    ReadSeqTest {
-        #[clap(short = 's', default_value_t = 15)]
+        #[clap(short = 't', long, default_value_t = String::from("/tmp/disk-test.tmp"))]
+        tempfile: String,
+        #[clap(short = 's', long, default_value_t = 15)]
         size: u8,
     },
 
-    // disk write subcommand
+    // random disk read subcommand
-    #[clap(name = "write-test", about = "Write a large file to determine sequential disk write speeds.")]
+    #[clap(name = "read_rand", about = "Random 4K disk read speed test.")]
-    WriteTest {
+    ReadRandTest {
-        #[clap(short = 't', default_value_t = String::from("/tmp/disk-test.tmp"))]
+        #[clap(short = 't', long, default_value_t = String::from("/tmp/disk-test.tmp"))]
         tempfile: String,
-        #[clap(short = 's', default_value_t = 5)]
+        #[clap(short = 's', long, default_value_t = 15)]
         size: u8,
     },
+
+    // sequential disk write subcommand
+    #[clap(name = "write_seq", about = "Write a large file to determine sequential disk write speeds.")]
+    WriteSeqTest {
+        #[clap(short = 't', long, default_value_t = String::from("/tmp/disk-test.tmp"))]
+        tempfile: String,
+        #[clap(short = 's', long, default_value_t = 15)]
+        size: u8,
+    },
+
+    // random 4K disk write subcommand
+    #[clap(name = "write_rand", about = "Write a bunch of smallfiles to determine random disk write speeds.")]
+    WriteRandTest {
+        #[clap(short = 't', long, default_value_t = String::from("/tmp/disk-test.tmp"))]
+        tempfile: String,
+        #[clap(short = 's', long, default_value_t = 15)]
+        size: u8,
+    },
+}
+
+#[derive(Parser)]
+struct Games {
+    #[structopt(subcommand)]
+    games_commands: GamesCommands,
+}
+
+#[derive(Subcommand)]
+enum GamesCommands {
+    // Civilization 6 AI benchmark subcommand
+    #[clap(name = "civ6_ai", about = "Run the Civilization 6 AI benchmark via Steam.")]
+    Civ6AI {},
+
+    // CS:GO benchmark subcommand
+    #[clap(name = "csgo", about = "Run the CS:GO game benchmark via Steam.")]
+    CSGO {},
+
+    // Deus Ex: Mankind Divided benchmark subcommand
+    #[clap(name = "demd", about = "Run the Deus Ex: Mankind Divided game benchmark via Steam.")]
+    DEMD {},
 }
 
 #[derive(Parser)]
@@ -53,22 +123,33 @@ struct Net {
 
 #[derive(Subcommand)]
 enum NetCommands {
-    // ping subcommand
+    // bandwidth test subcommand
-    #[clap(name = "ping", about = "Ping a host to determine network latency.")]
+    #[clap(name = "bandwidth", about = "Uses iperf to test network bandwidth.")]
-    Ping {
+    Bandwidth {
-        #[clap(short = 't', default_value_t = String::from("8.8.8.8"))]
+        #[clap(short = 'a', long, required = true)]
         host: String,
-        #[clap(short = 'c', default_value_t = 30)]
-        count: u16,
     },
 
-    // bandwidth test subcommand
+    // jitter subcommand
-    #[clap(name = "bandwidth", about = "Downloads a remote file to determine network bandwidth.")]
+    #[clap(name = "jitter", about = "Ping a host to determine network jitter.")]
-    Bandwidth {
+    Jitter {
-        #[clap(short = 'd', default_value_t = String::from("https://www.bitgoblin.tech/hardware-tests/export-01.mp4"))]
+        #[clap(short = 'a', long, default_value_t = String::from("8.8.8.8"))]
-        download: String,
+        address: String,
-        #[clap(short = 'o', default_value_t = String::from("./tempfile"))]
+        #[clap(short = 'c', long, default_value_t = 100)]
-        output: String,
+        count: u16,
+        #[clap(short = 'i', long, default_value_t = 1000)]
+        interval: u16,
+    },
+
+    // latency subcommand
+    #[clap(name = "latency", about = "Ping a host to determine network latency.")]
+    Latency {
+        #[clap(short = 'a', long, default_value_t = String::from("8.8.8.8"))]
+        address: String,
+        #[clap(short = 'c', long, default_value_t = 100)]
+        count: u16,
+        #[clap(short = 'i', long, default_value_t = 1000)]
+        interval: u16,
     },
 }
 
@@ -77,14 +158,62 @@ fn main() {
 
     // map subcommands back to the main command
     match &cli.command {
+        Commands::Cpu(args) => match &args.cpu_commands {
+            CpuCommands::StressTest { runtime, threads } => stress::cpu::cpu_stress_math(*runtime, *threads),
+        },
+
         Commands::Disk(args) => match &args.disk_commands {
-            DiskCommands::ReadTest { size } => tests::disk::disk_read_test(size),
+            DiskCommands::ReadSeqTest { tempfile, size } => {
-            DiskCommands::WriteTest { tempfile, size } => tests::disk::disk_write_test(tempfile, size),
+                for i in 0..cli.loopcount {
+                    println!("Test run number {}.", i + 1);
+                    benchmarks::disk::disk_read_seq_test(tempfile, size);
                 }
+            },
+            DiskCommands::ReadRandTest { tempfile, size } => {
+                for i in 0..cli.loopcount {
+                    println!("Test run number {}.", i + 1);
+                    benchmarks::disk::disk_read_rand_test(tempfile, size);
+                }
+            },
+            DiskCommands::WriteSeqTest { tempfile, size } => {
+                for i in 0..cli.loopcount {
+                    println!("Test run number {}.", i + 1);
+                    benchmarks::disk::disk_write_seq_test(tempfile, size);
+                }
+            },
+            DiskCommands::WriteRandTest { tempfile, size } => {
+                for i in 0..cli.loopcount {
+                    println!("Test run number {}.", i + 1);
+                    benchmarks::disk::disk_write_rand_test(tempfile, size);
+                }
+            },
+        },
+
+        Commands::Games(args) => match &args.games_commands {
+            GamesCommands::Civ6AI {} => benchmarks::games::run_civ6_ai_benchmark(),
+            GamesCommands::CSGO {} => benchmarks::games::run_csgo_benchmark(),
+            GamesCommands::DEMD {} => benchmarks::games::run_demd_benchmark(),
+        },
 
         Commands::Net(args) => match &args.net_commands {
-            NetCommands::Ping { host, count } => tests::network::ping_host(host, count),
+            NetCommands::Bandwidth { host } => {
-            NetCommands::Bandwidth { download, output } => tests::network::bandwidth_test(download, output),
+                for i in 0..cli.loopcount {
+                    println!("Test run number {}.", i + 1);
+                    benchmarks::network::bandwidth_test(host);
+                }
+            },
+            NetCommands::Jitter { address, count, interval } => {
+                for i in 0..cli.loopcount {
+                    println!("Test run number {}.", i + 1);
+                    benchmarks::network::jitter_test(address, count, interval);
+                }
+            },
+            NetCommands::Latency { address, count, interval } => {
+                for i in 0..cli.loopcount {
+                    println!("Test run number {}.", i + 1);
+                    benchmarks::network::latency_test(address, count, interval);
+                }
+            },
         },
     }
 }

src/stress/cpu.rs

@@ -0,0 +1,38 @@
+use std::{thread, time};
+use std::process::exit;
+use sysinfo::{System,SystemExt};
+
+pub fn cpu_stress_math(runtime: u16, threads: usize) {
+    // fetch system information
+    let mut sys = System::new_all();
+    sys.refresh_all();
+    let num_cpus = sys.cpus().len();
+
+    let mut num_threads = threads;
+    if num_threads == 0 {
+        println!("Number of threads not specified, defaulting to CPU's thread count of {}.", num_cpus);
+        num_threads = num_cpus;
+    } else {
+        println!("Using specified thread count of {}", num_threads);
+    }
+
+    for i in 0..num_threads {
+        println!("Spawning thread number {}", i + 1);
+        thread::spawn (|| {
+            worker();
+        });
+    }
+
+    println!("Sleeping main thread for the allotted runtime of {} minute(s).", runtime);
+    let duration = time::Duration::from_secs((runtime * 60).into());
+    thread::sleep(duration);
+    exit(0);
+}
+
+fn worker() {
+    let mut _x = 0;
+    loop {
+        _x += 1;
+        _x -= 1;
+    }
+}

src/stress/mod.rs

@@ -0,0 +1 @@
+pub mod cpu;

src/tests/disk.rs

@@ -1,56 +0,0 @@
-use std::fs;
-use std::process::Command;
-
-// test disk read speeds by reading for /dev/zero and writing it to /dev/null
-pub fn disk_read_test(size: &u8) {
-    // convert size in Gigabytes down to Megabytes
-    let size_gigs: u32 = (*size as u32 * 1024 * 8).into();
-
-    // run sync to clear out any disk caches prior to running
-    Command::new("sync");
-
-    // run the dd command
-    let output = Command::new("dd")
-        .arg("bs=128k")
-        .arg(format!("count={}", size_gigs))
-        .arg("if=/dev/zero")
-        .arg("of=/dev/null")
-        .output()
-        .expect("Failed to execute command");
-
-    // check that the command succeeded
-    assert!(output.status.success());
-
-    // dd's output ends up in stderr
-    println!("{}", String::from_utf8_lossy(&output.stderr));
-
-    // run another sync to clear out the disk's cache
-    Command::new("sync");
-}
-
-// test disk write speeds by continually writing zeroes to it
-pub fn disk_write_test(tempfile: &str, size: &u8) {
-    // convert size in Gigabytes down to Megabytes
-    let size_gigs: u32 = (*size as u32 * 1024).into();
-
-    // run the dd command with a block size of 1 MB
-    let output = Command::new("dd")
-        .arg("bs=1M")
-        .arg(format!("count={}", size_gigs))
-        .arg("if=/dev/zero")
-        .arg(format!("of={}", tempfile))
-        .output()
-        .expect("Failed to execute command");
-
-    // check that the command succeeded
-    assert!(output.status.success());
-
-    // for whatever reason, `dd` output ends up in stderr
-    println!("{}", String::from_utf8_lossy(&output.stderr));
-
-    // remove the test file
-    match fs::remove_file(tempfile) {
-        Ok(()) => println!("Cleaning up..."),
-        Err(e) => println!("There was a problem during cleanup - {}", e),
-    }
-}

src/tests/network.rs

@@ -1,42 +0,0 @@
-use chrono::prelude::*;
-use std::{fs,process};
-
-// ping a host
-pub fn ping_host(host: &str, count: &u16) {
-    println!("Pinging host {}, {} times.", host, count);
-
-    // run the ping command
-    let output = process::Command::new("ping")
-        .arg(host)
-        .arg(format!("-c {}", count))
-        .output()
-        .expect("Failed to execute command");
-
-    // check that the command succeeded
-    assert!(output.status.success());
-
-    // print out the ping results from stdout
-    println!("{}", String::from_utf8_lossy(&output.stdout));
-}
-
-// timed file copy test to guage bandwidth speeds
-pub fn bandwidth_test(download: &str, output: &str) {
-    println!("Testing network bandwidth by downloading {}.", download);
-
-    // get start time so we can track how long it takes to complete
-    let start_time = Utc::now();
-
-    // do the download
-
-    // get finish time
-    let finish_time = Utc::now();
-    // compute time to complete
-    let comp_time = finish_time - start_time;
-    println!("{}", comp_time.num_milliseconds());
-
-    // clean up the test file
-    match fs::remove_file(output) {
-        Ok(()) => println!("Cleaning up..."),
-        Err(e) => println!("There was a problem during cleanup - {}", e),
-    }
-}

src/text/format.rs

@@ -0,0 +1,8 @@
+use std::vec::Vec;
+
+pub fn trim_output(text: &str, linecount: u16) -> Vec<&str> {
+    let text_vec: Vec<&str> = text.split("\n").collect();
+    let text_start = text_vec.len() - (linecount as usize);
+    let text_trim = text_vec.as_slice()[text_start..].to_vec();
+    return text_trim;
+}

src/text/mod.rs

@@ -0,0 +1 @@
+pub mod format;