Version bump to v0.3.3

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "hardware-tests"
 description = "Bit Goblin PC hardware test suite."
-version = "0.3.2"
+version = "0.3.3"
 edition = "2021"
 readme = "README.md"
 license = "BSD 2-Clause"
@@ -12,9 +12,9 @@ name = "bgbench"
 path = "src/main.rs"
 
 [dependencies]
-chrono = "0.4.20"
-clap = { version = "3.2.16", features = ["derive"] }
-sysinfo = "0.25.1"
+chrono = "0.4"
+clap = { version = "3.2", features = ["derive"] }
+sysinfo = "0.25"
 
 [package.metadata.deb]
 depends = "fio"

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

@@ -1,5 +1,4 @@
-use chrono::prelude::*;
-use std::{fs,process};
+use std::process;
 
 use crate::text;
 
@@ -60,23 +59,20 @@ pub fn jitter_test(address: &str, count: &u16) {
 }
 
 // timed file copy test to guage bandwidth speeds
-pub fn bandwidth_test(download: &str, output: &str) {
-    println!("Testing network bandwidth by downloading {}.", download);
+pub fn bandwidth_test(host: &str) {
+    println!("Testing network bandwidth using iperf; connecting to {}.", host);
+    println!("{}", host);
 
-    // get start time so we can track how long it takes to complete
-    let start_time = Utc::now();
+    let output = process::Command::new("iperf3")
+        .arg("-c")
+        .arg(host)
+        .output()
+        .expect("Failed to execute command");
 
-    // do the download
+    // check that the command succeeded
+    assert!(output.status.success());
 
-    // 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),
-    }
+    // grab and print the command's results
+    let results_raw = &String::from_utf8_lossy(&output.stdout);
+    println!("{}", results_raw);
 }

src/main.rs

@@ -23,6 +23,9 @@ enum Commands {
     // disk benchmarks subcommand
     #[clap(name = "disk", about = "Hard drive and SSD benchmarks.")]
     Disk(Disk),
+    // 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),
@@ -91,6 +94,27 @@ enum DiskCommands {
     },
 }
 
+#[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)]
 struct Net {
     #[structopt(subcommand)]
@@ -118,12 +142,10 @@ enum NetCommands {
     },
 
     // bandwidth test subcommand
-    #[clap(name = "bandwidth", about = "Downloads a remote file to determine network bandwidth.")]
+    #[clap(name = "bandwidth", about = "Uses iperf to test network bandwidth.")]
     Bandwidth {
-        #[clap(short = 'd', long, default_value_t = String::from("https://www.bitgoblin.tech/hardware-tests/export-01.mp4"))]
-        download: String,
-        #[clap(short = 't', long, default_value_t = String::from("/tmp/bw-test.tmp"))]
-        output: String,
+        #[clap(short = 'a', long, required = true)]
+        host: String,
     },
 }
 
@@ -161,7 +183,13 @@ fn main() {
                     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 { address, count } => {
@@ -176,10 +204,10 @@ fn main() {
                     benchmarks::network::jitter_test(address, count);
                 }
             },
-            NetCommands::Bandwidth { download, output } => {
+            NetCommands::Bandwidth { host } => {
                 for i in 0..cli.iterations {
                     println!("Test run number {}.", i + 1);
-                    benchmarks::network::bandwidth_test(download, output);
+                    benchmarks::network::bandwidth_test(host);
                 }
             },
         },