+// flow-texpack: A program that will allow you to generate texture atlas.
+// public domain License
+
+use assert_cmd::cargo::*;
+use std::path::PathBuf;
+
+use flow_texpack::{Texture, exists_file, remove_dir_all, remove_file};
+
+fn verify_texture_size(image_path: &PathBuf, width: u32, height: u32) {
+ let mut t1 = Texture::new();
+ t1.load(image_path, false, false, false, 0, 1024);
+ assert_eq!(t1.width, width);
+ assert_eq!(t1.height, height);
+}
+
+fn validate_descriptor_json(json_path: &PathBuf) {
+ let contents = std::fs::read_to_string(json_path).unwrap();
+ let mut lines = contents.lines();
+
+ assert_eq!(Some("{"), lines.next());
+ assert_eq!(Some("\t\"ImageAtlas\":"), lines.next());
+ assert_eq!(Some("\t{"), lines.next());
+ assert_eq!(Some("\t\t\"info\":"), lines.next());
+ assert_eq!(Some("\t\t{"), lines.next());
+ assert_eq!(Some("\t\t\t\"numberOfAtlasImages\": 1,"), lines.next());
+ assert_eq!(
+ Some("\t\t\t\"generatedWith\": \"https://luflow.net/git-repos/flow-texpack.git\""),
+ lines.next()
+ );
+ assert_eq!(Some("\t\t},"), lines.next());
+ assert_eq!(Some("\t\t\"AtlasImage\":"), lines.next());
+ assert_eq!(Some("\t\t["), lines.next());
+
+ // files part:
+ assert_eq!(Some("\t\t\t{"), lines.next());
+ assert_eq!(Some("\t\t\t\t\"n\": \"atlas0.png\","), lines.next());
+ assert_eq!(Some("\t\t\t\t\"numImages\": 2,"), lines.next());
+ assert_eq!(Some("\t\t\t\t\"width\": 64,"), lines.next());
+ assert_eq!(Some("\t\t\t\t\"height\": 64,"), lines.next());
+ assert_eq!(Some("\t\t\t\t\"generateMipMaps\": 1,"), lines.next());
+ assert_eq!(Some("\t\t\t\t\"img\":"), lines.next());
+ assert_eq!(Some("\t\t\t\t["), lines.next());
+ assert_eq!(Some("\t\t\t\t\t{"), lines.next());
+ assert_eq!(
+ Some(
+ "\t\t\t\t\t\t\"n\": \"white_32x32.png\", \"x\": 0, \"y\": 0, \"w\": 32, \"h\": 32, \"trimmed\": 0, \"rotated\": 0, \"fx\": 0, \"fy\": 0, \"fw\": 32, \"fh\": 32"
+ ),
+ lines.next()
+ );
+ assert_eq!(Some("\t\t\t\t\t},"), lines.next());
+ assert_eq!(Some("\t\t\t\t\t{"), lines.next());
+ assert_eq!(
+ Some(
+ "\t\t\t\t\t\t\"n\": \"white_32x16.png\", \"x\": 0, \"y\": 36, \"w\": 32, \"h\": 16, \"trimmed\": 0, \"rotated\": 0, \"fx\": 0, \"fy\": 0, \"fw\": 32, \"fh\": 16"
+ ),
+ lines.next()
+ );
+ assert_eq!(Some("\t\t\t\t\t}"), lines.next());
+ assert_eq!(Some("\t\t\t\t]"), lines.next());
+ assert_eq!(Some("\t\t\t}"), lines.next());
+
+ assert_eq!(Some("\t\t]"), lines.next());
+ assert_eq!(Some("\t}"), lines.next());
+ assert_eq!(Some("}"), lines.next());
+}
+
+fn validate_descriptor_txt(txt_path: &PathBuf, with_header: bool) {
+ let contents = std::fs::read_to_string(txt_path).unwrap();
+ let mut lines = contents.lines();
+
+ if with_header {
+ assert_eq!(Some("/*"), lines.next());
+ assert_eq!(
+ Some("\t ************************************************"),
+ lines.next()
+ );
+ assert_eq!(
+ Some("\t * Generated with: https://luflow.net/git-repos/flow-texpack.git"),
+ lines.next()
+ );
+ assert_eq!(
+ Some("\t ************************************************"),
+ lines.next()
+ );
+ assert_eq!(Some(""), lines.next());
+ assert_eq!(
+ Some("\t ************************************************"),
+ lines.next()
+ );
+ assert_eq!(Some("\t * Format description:"), lines.next());
+ assert_eq!(
+ Some("\t ************************************************"),
+ lines.next()
+ );
+ assert_eq!(Some("\t [info]"), lines.next());
+ assert_eq!(Some("\t numberOfAtlasImages,generatedWith"), lines.next());
+ assert_eq!(Some(""), lines.next());
+ assert_eq!(
+ Some("\t [AtlasImage (repeated numberOfAtlasImages)]"),
+ lines.next()
+ );
+ assert_eq!(
+ Some(
+ "\t atlasImageName,numberOfImages,atlasImageWidth,atlasImageHeight,generateMipMaps"
+ ),
+ lines.next()
+ );
+ assert_eq!(Some(""), lines.next());
+ assert_eq!(Some("\t [Image (repeated numberOfImages)]"), lines.next());
+ assert_eq!(
+ Some(
+ "\t name,x,y,w,h,trimmed,rotated,fx,fy,fw,fh (NOTE: fx,fy,fw,fh valid if trimmed==1)"
+ ),
+ lines.next()
+ );
+ assert_eq!(Some(""), lines.next());
+ assert_eq!(Some("\t Text format example:"), lines.next());
+ assert_eq!(Some("\t [info]"), lines.next());
+ assert_eq!(Some("\t [AtlasImage]"), lines.next());
+ assert_eq!(Some("\t [Image]"), lines.next());
+ assert_eq!(Some("\t [Image]"), lines.next());
+ assert_eq!(Some("\t ..."), lines.next());
+ assert_eq!(Some("\t [AtlasImage]"), lines.next());
+ assert_eq!(Some("\t [Image]"), lines.next());
+ assert_eq!(Some("\t [Image]"), lines.next());
+ assert_eq!(Some("\t ..."), lines.next());
+ assert_eq!(Some("*/@"), lines.next());
+ }
+
+ assert_eq!(
+ Some("1,https://luflow.net/git-repos/flow-texpack.git"),
+ lines.next()
+ );
+ assert_eq!(Some("atlas0.png,2,64,64,1"), lines.next());
+ assert_eq!(
+ Some("white_32x32.png,0,0,32,32,0,0,0,0,32,32"),
+ lines.next()
+ );
+ assert_eq!(
+ Some("white_32x16.png,0,36,32,16,0,0,0,0,32,16"),
+ lines.next()
+ );
+}
+
+fn get_hash_value(hash_path: &PathBuf) -> u64 {
+ let result = std::fs::read_to_string(hash_path);
+
+ let old_hash_value = match result {
+ Ok(old_hash_value) => old_hash_value.parse().unwrap(),
+ Err(_) => 0,
+ };
+
+ return old_hash_value;
+}
+
+// *************************************************
+// Integration tests that should fail:
+// *************************************************
+#[test]
+fn cli_error_no_arguments() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+
+ cmd.assert().failure();
+
+ Ok(())
+}
+
+#[test]
+fn cli_error_no_input() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+
+ cmd.arg("-i");
+ cmd.assert().failure();
+
+ Ok(())
+}
+
+#[test]
+fn cli_error_no_input_v2() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+
+ cmd.arg("--input");
+ cmd.assert().failure();
+
+ Ok(())
+}
+
+#[test]
+fn cli_error_no_input_v3() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+
+ cmd.arg("-i").arg("test_data2");
+ cmd.assert().failure();
+
+ Ok(())
+}
+
+#[test]
+fn cli_error_no_input_file() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+
+ cmd.arg("--input-file");
+ cmd.assert().failure();
+
+ Ok(())
+}
+
+#[test]
+fn cli_error_no_input_file_v2() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+
+ cmd.arg("--input-file").arg("test_data/input_not_found.txt");
+ cmd.assert().failure();
+
+ Ok(())
+}
+
+#[test]
+fn cli_error_no_exclude_file() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+
+ cmd.arg("-i").arg("test_data").arg("--exclude-file");
+ cmd.assert().failure();
+
+ Ok(())
+}
+
+#[test]
+fn cli_error_no_exclude_file_v2() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+
+ cmd.arg("-i")
+ .arg("test_data")
+ .arg("--exclude-file")
+ .arg("test_data/exclude_not_found.txt");
+ cmd.assert().failure();
+
+ Ok(())
+}
+
+#[test]
+fn cli_error_no_output() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+
+ cmd.arg("-i").arg("test_data").arg("-o");
+ cmd.assert().failure();
+
+ Ok(())
+}
+
+#[test]
+fn cli_error_no_output_v2() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+
+ cmd.arg("-i").arg("test_data").arg("--output");
+ cmd.assert().failure();
+
+ Ok(())
+}
+
+#[test]
+fn cli_error_invalid_atlas_descriptor() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+
+ cmd.arg("-i")
+ .arg("test_data")
+ .arg("-o")
+ .arg("test_data/out/atlas")
+ .arg("--atlas-descriptor")
+ .arg("invalid");
+ cmd.assert().failure();
+
+ Ok(())
+}
+
+#[test]
+fn cli_error_invalid_atlas_image() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+
+ cmd.arg("-i")
+ .arg("test_data")
+ .arg("-o")
+ .arg("test_data/out/atlas")
+ .arg("--atlas-image")
+ .arg("invalid");
+ cmd.assert().failure();
+
+ Ok(())
+}
+
+#[test]
+fn cli_error_invalid_atlas_size() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+
+ cmd.arg("-i")
+ .arg("test_data")
+ .arg("-o")
+ .arg("test_data/out/atlas")
+ .arg("--atlas-size")
+ .arg("invalid");
+ cmd.assert().failure();
+
+ Ok(())
+}
+
+#[test]
+fn cli_error_invalid_load_filter() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+
+ cmd.arg("-i")
+ .arg("test_data")
+ .arg("-o")
+ .arg("test_data/out/atlas")
+ .arg("--load-filter")
+ .arg("invalid");
+ cmd.assert().failure();
+
+ Ok(())
+}
+
+#[test]
+fn cli_error_invalid_max_atlases() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+
+ cmd.arg("-i")
+ .arg("test_data")
+ .arg("-o")
+ .arg("test_data/out/atlas")
+ .arg("--max-atlases")
+ .arg("4097");
+ cmd.assert().failure();
+
+ Ok(())
+}
+
+#[test]
+fn cli_error_invalid_padding() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+
+ cmd.arg("-i")
+ .arg("test_data")
+ .arg("-o")
+ .arg("test_data/out/atlas")
+ .arg("-p")
+ .arg("17");
+ cmd.assert().failure();
+
+ Ok(())
+}
+
+#[test]
+fn cli_error_invalid_padding_v2() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+
+ cmd.arg("-i")
+ .arg("test_data")
+ .arg("-o")
+ .arg("test_data/out/atlas")
+ .arg("--pad")
+ .arg("17");
+ cmd.assert().failure();
+
+ Ok(())
+}
+
+#[test]
+fn cli_error_invalid_rect_heuristic() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+
+ cmd.arg("-i")
+ .arg("test_data")
+ .arg("-o")
+ .arg("test_data/out/atlas")
+ .arg("--rect-heuristic")
+ .arg("invalid");
+ cmd.assert().failure();
+
+ Ok(())
+}
+
+// *************************************************
+// Integration tests that should succeed:
+// *************************************************
+#[test]
+fn cli_success_input_defaults() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/white_32x32.png")
+ .arg("-o")
+ .arg(out_file_path);
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 64, 64);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_v2() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_v2/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("--input")
+ .arg("test_data/white_32x32.png")
+ .arg("-o")
+ .arg(out_file_path);
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 64, 64);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_with_exclude_defaults() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_with_exclude_defaults/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/white_32x32.png")
+ .arg("test_data/blue_32x32.png")
+ .arg("-e")
+ .arg("test_data/white_32x32.png")
+ .arg("-o")
+ .arg(out_file_path);
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 64, 64);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_with_exclude_defaults_v2() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_with_exclude_defaults_v2/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/white_32x32.png")
+ .arg("test_data/blue_32x32.png")
+ .arg("--exclude")
+ .arg("test_data/white_32x32.png")
+ .arg("-o")
+ .arg(out_file_path);
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 64, 64);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_verbose() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_verbose/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/white_32x32.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("-v");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 64, 64);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_verbose_v2() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_verbose_v2/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/white_32x32.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("--verbose");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 64, 64);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_log() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_log/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/white_32x32.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("-l");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+ let log_path = PathBuf::from("flow-texpack.log");
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+ assert_eq!(exists_file(&log_path), true);
+
+ verify_texture_size(&image_path, 64, 64);
+
+ remove_dir_all(&parent_path);
+ remove_file(&log_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+ assert_eq!(exists_file(&log_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_version() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+
+ cmd.arg("-V");
+ cmd.assert().success();
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_version_v2() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+
+ cmd.arg("--version");
+ cmd.assert().success();
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_help() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+
+ cmd.arg("-h");
+ cmd.assert().success();
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_help_v2() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+
+ cmd.arg("--help");
+ cmd.assert().success();
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_force() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_force/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/white_32x32.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("-f");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) == 0, true);
+
+ verify_texture_size(&image_path, 64, 64);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_force_v2() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_force_v2/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/white_32x32.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("--force");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) == 0, true);
+
+ verify_texture_size(&image_path, 64, 64);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_force_square() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_force_square/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/white_32x16.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("--force-square");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 1024, 1024);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_atlas_image_png() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_atlas_image_png/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/green_32x32.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("--atlas-image")
+ .arg("png");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 64, 64);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_atlas_image_tga() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_atlas_image_tga/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/green_32x32.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("--atlas-image")
+ .arg("tga");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.tga", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 64, 64);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_atlas_image_tiff() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_atlas_image_tiff/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/green_32x32.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("--atlas-image")
+ .arg("tiff");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.tiff", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 64, 64);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_atlas_image_webp() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_atlas_image_webp/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/green_32x32.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("--atlas-image")
+ .arg("webp");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.webp", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 64, 64);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_atlas_descriptor_json() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_atlas_descriptor_json/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/green_32x32.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("--atlas-descriptor")
+ .arg("json");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 64, 64);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_atlas_descriptor_txt() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_atlas_descriptor_txt/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/green_32x32.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("--atlas-descriptor")
+ .arg("txt");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.txt", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 64, 64);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_atlas_descriptor_txt_desc() -> Result<(), Box<dyn std::error::Error>>
+{
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_atlas_descriptor_txt_desc/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/green_32x32.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("--atlas-descriptor")
+ .arg("txt");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.txt", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 64, 64);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_atlas_size_64() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_atlas_size_64/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/white_32x32.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("--atlas-size")
+ .arg("pot64")
+ .arg("--force-square");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 64, 64);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_atlas_size_128() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_atlas_size_128/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/white_32x32.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("--atlas-size")
+ .arg("pot128")
+ .arg("--force-square");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 128, 128);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_atlas_size_256() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_atlas_size_256/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/white_32x32.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("--atlas-size")
+ .arg("pot256")
+ .arg("--force-square");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 256, 256);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_atlas_size_512() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_atlas_size_512/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/white_32x32.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("--atlas-size")
+ .arg("pot512")
+ .arg("--force-square");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 512, 512);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_atlas_size_1024() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_atlas_size_1024/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/white_32x32.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("--atlas-size")
+ .arg("pot1024")
+ .arg("--force-square");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 1024, 1024);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_atlas_size_2048() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_atlas_size_2048/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/white_32x32.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("--atlas-size")
+ .arg("pot2048")
+ .arg("--force-square");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 2048, 2048);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_atlas_size_4096() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_atlas_size_4096/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/white_32x32.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("--atlas-size")
+ .arg("pot4096")
+ .arg("--force-square");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 4096, 4096);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_atlas_size_8192() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_atlas_size_8192/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/white_32x32.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("--atlas-size")
+ .arg("pot8192")
+ .arg("--force-square");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 8192, 8192);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_rect_heuristic_short_side_fit()
+-> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_rect_heuristic_short_side_fit/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/white_32x32.png")
+ .arg("test_data/red_32x32.png")
+ .arg("test_data/green_32x32.png")
+ .arg("test_data/blue_32x32.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("-p")
+ .arg("0")
+ .arg("--atlas-size")
+ .arg("pot64")
+ .arg("--rect-heuristic")
+ .arg("short-side-fit");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 64, 64);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_rect_heuristic_long_side_fit()
+-> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_rect_heuristic_long_side_fit/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/white_32x32.png")
+ .arg("test_data/red_32x32.png")
+ .arg("test_data/green_32x32.png")
+ .arg("test_data/blue_32x32.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("-p")
+ .arg("0")
+ .arg("--atlas-size")
+ .arg("pot64")
+ .arg("--rect-heuristic")
+ .arg("long-side-fit");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 64, 64);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_rect_heuristic_area_fit() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_rect_heuristic_area_fit/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/white_32x32.png")
+ .arg("test_data/red_32x32.png")
+ .arg("test_data/green_32x32.png")
+ .arg("test_data/blue_32x32.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("-p")
+ .arg("0")
+ .arg("--atlas-size")
+ .arg("pot64")
+ .arg("--rect-heuristic")
+ .arg("area-fit");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 64, 64);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_rect_heuristic_bottom_left() -> Result<(), Box<dyn std::error::Error>>
+{
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_rect_heuristic_bottom_left/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/white_32x32.png")
+ .arg("test_data/red_32x32.png")
+ .arg("test_data/green_32x32.png")
+ .arg("test_data/blue_32x32.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("-p")
+ .arg("0")
+ .arg("--atlas-size")
+ .arg("pot64")
+ .arg("--rect-heuristic")
+ .arg("bottom-left");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 64, 64);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_rect_heuristic_contact_point()
+-> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_rect_heuristic_contact_point/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/white_32x32.png")
+ .arg("test_data/red_32x32.png")
+ .arg("test_data/green_32x32.png")
+ .arg("test_data/blue_32x32.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("-p")
+ .arg("0")
+ .arg("--atlas-size")
+ .arg("pot64")
+ .arg("--rect-heuristic")
+ .arg("contact-point");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 64, 64);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_premultiply() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_premultiply/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/white_32x32.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("-p")
+ .arg("0");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 32, 32);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_trim() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_trim/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/blue_trimmable_128x128.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("-p")
+ .arg("0")
+ .arg("-t");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 32, 32);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_unique() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_unique/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/white_128x128.png")
+ .arg("test_data/white_128x128_v2.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("-p")
+ .arg("0")
+ .arg("-u");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 128, 128);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_rotate() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_rotate/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/white_128x64.png")
+ .arg("test_data/white_32x16.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("--rect-heuristic")
+ .arg("long-side-fit")
+ .arg("-r");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 256, 128);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_adjust_size() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_adjust_size/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/white_128x128.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("--atlas-size")
+ .arg("pot64")
+ .arg("-p")
+ .arg("0")
+ .arg("--adjust-size");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 128, 128);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_adjust_fit() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_adjust_fit/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/white_128x128.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("--atlas-size")
+ .arg("pot64")
+ .arg("-p")
+ .arg("0")
+ .arg("--adjust-fit");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 64, 64);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_validate_descriptor_json() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_validate_descriptor_json/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/white_32x32.png")
+ .arg("test_data/white_32x16.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("--atlas-size")
+ .arg("pot64")
+ .arg("--generate-mipmaps")
+ .arg("-p")
+ .arg("4");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 64, 64);
+ validate_descriptor_json(&json_path);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_validate_descriptor_txt() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_validate_descriptor_txt/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/white_32x32.png")
+ .arg("test_data/white_32x16.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("--atlas-size")
+ .arg("pot64")
+ .arg("--atlas-descriptor")
+ .arg("txt")
+ .arg("--generate-mipmaps")
+ .arg("-p")
+ .arg("4");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let txt_path = PathBuf::from(format!("{}.txt", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&txt_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 64, 64);
+ validate_descriptor_txt(&txt_path, false);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&txt_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_validate_descriptor_txt_header()
+-> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_validate_descriptor_txt_header/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/white_32x32.png")
+ .arg("test_data/white_32x16.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("--atlas-size")
+ .arg("pot64")
+ .arg("--atlas-descriptor")
+ .arg("txt-desc")
+ .arg("--generate-mipmaps")
+ .arg("--pad")
+ .arg("4");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let txt_path = PathBuf::from(format!("{}.txt", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&txt_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 64, 64);
+ validate_descriptor_txt(&txt_path, true);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&txt_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_load_filter_bmp() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_load_filter_bmp/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/white_32x32.bmp")
+ .arg("test_data/white_128x128.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("--load-filter")
+ .arg("bmp");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 64, 64);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_load_filter_hdr() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_load_filter_hdr/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/white_32x32.hdr")
+ .arg("test_data/white_128x128.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("--load-filter")
+ .arg("hdr");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 64, 64);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_load_filter_jpg() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_load_filter_jpg/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/white_32x32.jpg")
+ .arg("test_data/white_128x128.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("--load-filter")
+ .arg("jpg");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 64, 64);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_load_filter_png() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_load_filter_png/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/white_32x32.png")
+ .arg("test_data/white_128x128.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("--load-filter")
+ .arg("png");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 256, 256);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_load_filter_tga() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_load_filter_tga/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/white_32x32.tga")
+ .arg("test_data/white_128x128.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("--load-filter")
+ .arg("tga");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 64, 64);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_load_filter_tiff() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_load_filter_tiff/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/white_32x32.tiff")
+ .arg("test_data/white_128x128.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("--load-filter")
+ .arg("tiff");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 64, 64);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
+
+#[test]
+fn cli_success_input_defaults_load_filter_webp() -> Result<(), Box<dyn std::error::Error>> {
+ let mut cmd = cargo_bin_cmd!("flow-texpack");
+ let out_file_path = "test_data/cli_success_input_defaults_load_filter_webp/atlas";
+ let parent_path = PathBuf::from(PathBuf::from(out_file_path).parent().unwrap());
+
+ cmd.arg("-i")
+ .arg("test_data/white_32x32.webp")
+ .arg("test_data/white_128x128.png")
+ .arg("-o")
+ .arg(out_file_path)
+ .arg("--load-filter")
+ .arg("webp");
+ cmd.assert().success();
+
+ let hash_path = PathBuf::from(format!("{}.hash", out_file_path));
+ let json_path = PathBuf::from(format!("{}.json", out_file_path));
+ let image_path = PathBuf::from(format!("{}0.png", out_file_path));
+
+ assert_eq!(exists_file(&hash_path), true);
+ assert_eq!(exists_file(&json_path), true);
+ assert_eq!(exists_file(&image_path), true);
+ assert_eq!(get_hash_value(&hash_path) > 0, true);
+
+ verify_texture_size(&image_path, 64, 64);
+
+ remove_dir_all(&parent_path);
+
+ assert_eq!(exists_file(&hash_path), false);
+ assert_eq!(exists_file(&json_path), false);
+ assert_eq!(exists_file(&image_path), false);
+
+ Ok(())
+}
home / projects / flow-texpack.git / commitdiff
