2068 lines
66 KiB
Rust
2068 lines
66 KiB
Rust
// 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/hfsoulz/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/hfsoulz/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/hfsoulz/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(())
|
|
}
|