panopainter/tests/app_core/document_layer_tests.cpp

#include "app_core/document_layer.h"
#include "test_harness.h"

#include <cmath>
#include <string>

namespace {

void layer_rename_records_changed_name(pp::tests::Harness& harness)
{
    const auto plan = pp::app::plan_document_layer_rename("Base", "Paint");
    PP_EXPECT(harness, plan);
    if (plan) {
        PP_EXPECT(harness, plan.value().old_name == "Base");
        PP_EXPECT(harness, plan.value().new_name == "Paint");
        PP_EXPECT(
            harness,
            plan.value().action == pp::app::DocumentLayerRenameAction::rename_and_record_undo);
    }
}

void layer_rename_ignores_unchanged_name(pp::tests::Harness& harness)
{
    const auto plan = pp::app::plan_document_layer_rename("Ink", "Ink");
    PP_EXPECT(harness, plan);
    if (plan) {
        PP_EXPECT(harness, plan.value().old_name == "Ink");
        PP_EXPECT(harness, plan.value().new_name == "Ink");
        PP_EXPECT(
            harness,
            plan.value().action == pp::app::DocumentLayerRenameAction::no_op_same_name);
    }
}

void layer_rename_rejects_empty_name(pp::tests::Harness& harness)
{
    const auto plan = pp::app::plan_document_layer_rename("Ink", "");
    PP_EXPECT(harness, !plan);
    if (!plan) {
        PP_EXPECT(harness, plan.status().code == pp::foundation::StatusCode::invalid_argument);
    }
}

void layer_rename_rejects_overlong_name(pp::tests::Harness& harness)
{
    const std::string too_long(pp::app::document_layer_name_max_length + 1U, 'x');
    const auto plan = pp::app::plan_document_layer_rename("Ink", too_long);
    PP_EXPECT(harness, !plan);
    if (!plan) {
        PP_EXPECT(harness, plan.status().code == pp::foundation::StatusCode::out_of_range);
    }
}

void layer_add_validates_insert_index_and_name(pp::tests::Harness& harness)
{
    const auto plan = pp::app::plan_document_layer_add(2, 1, "Paint");
    PP_EXPECT(harness, plan);
    if (plan) {
        PP_EXPECT(harness, plan.value().operation == pp::app::DocumentLayerOperation::add);
        PP_EXPECT(harness, plan.value().insert_index == 1);
        PP_EXPECT(harness, plan.value().name == "Paint");
        PP_EXPECT(harness, plan.value().marks_unsaved);
        PP_EXPECT(harness, plan.value().reloads_animation_layers);
    }

    PP_EXPECT(harness, !pp::app::plan_document_layer_add(2, -1, "Paint"));
    PP_EXPECT(harness, !pp::app::plan_document_layer_add(2, 3, "Paint"));
    PP_EXPECT(harness, !pp::app::plan_document_layer_add(2, 1, ""));
}

void layer_duplicate_select_and_reorder_validate_indices(pp::tests::Harness& harness)
{
    const auto duplicate = pp::app::plan_document_layer_duplicate(3, 1);
    PP_EXPECT(harness, duplicate);
    if (duplicate) {
        PP_EXPECT(harness, duplicate.value().source_index == 1);
        PP_EXPECT(harness, duplicate.value().insert_index == 2);
        PP_EXPECT(harness, duplicate.value().marks_unsaved);
    }

    const auto select = pp::app::plan_document_layer_select(3, 2);
    PP_EXPECT(harness, select);
    if (select) {
        PP_EXPECT(harness, select.value().index == 2);
        PP_EXPECT(harness, !select.value().marks_unsaved);
        PP_EXPECT(harness, select.value().reloads_animation_layers);
    }

    const auto reorder = pp::app::plan_document_layer_reorder(3, 2, 0);
    PP_EXPECT(harness, reorder);
    if (reorder) {
        PP_EXPECT(harness, reorder.value().from_index == 2);
        PP_EXPECT(harness, reorder.value().to_index == 0);
        PP_EXPECT(harness, reorder.value().marks_unsaved);
    }

    const auto no_op_reorder = pp::app::plan_document_layer_reorder(3, 1, 1);
    PP_EXPECT(harness, no_op_reorder);
    if (no_op_reorder) {
        PP_EXPECT(harness, !no_op_reorder.value().mutates_document);
        PP_EXPECT(harness, !no_op_reorder.value().marks_unsaved);
    }

    PP_EXPECT(harness, !pp::app::plan_document_layer_duplicate(3, 3));
    PP_EXPECT(harness, !pp::app::plan_document_layer_select(3, -1));
    PP_EXPECT(harness, !pp::app::plan_document_layer_reorder(3, 0, 3));
}

void layer_remove_keeps_at_least_one_layer(pp::tests::Harness& harness)
{
    const auto plan = pp::app::plan_document_layer_remove(2, 0);
    PP_EXPECT(harness, plan);
    if (plan) {
        PP_EXPECT(harness, plan.value().operation == pp::app::DocumentLayerOperation::remove);
        PP_EXPECT(harness, plan.value().index == 0);
        PP_EXPECT(harness, plan.value().marks_unsaved);
        PP_EXPECT(harness, plan.value().reloads_animation_layers);
    }

    PP_EXPECT(harness, !pp::app::plan_document_layer_remove(1, 0));
    PP_EXPECT(harness, !pp::app::plan_document_layer_remove(2, 2));
}

void layer_metadata_plans_validate_values(pp::tests::Harness& harness)
{
    const auto opacity = pp::app::plan_document_layer_opacity(2, 1, 0.25F);
    PP_EXPECT(harness, opacity);
    if (opacity) {
        PP_EXPECT(harness, opacity.value().operation == pp::app::DocumentLayerOperation::set_opacity);
        PP_EXPECT(harness, opacity.value().opacity == 0.25F);
        PP_EXPECT(harness, opacity.value().marks_unsaved);
        PP_EXPECT(harness, !opacity.value().reloads_animation_layers);
    }

    const auto visibility = pp::app::plan_document_layer_visibility(2, 1, false);
    PP_EXPECT(harness, visibility);
    if (visibility) {
        PP_EXPECT(harness, visibility.value().operation == pp::app::DocumentLayerOperation::set_visibility);
        PP_EXPECT(harness, !visibility.value().flag);
        PP_EXPECT(harness, visibility.value().reloads_animation_layers);
    }

    const auto alpha_lock = pp::app::plan_document_layer_alpha_lock(2, 1, true);
    PP_EXPECT(harness, alpha_lock);
    if (alpha_lock) {
        PP_EXPECT(harness, alpha_lock.value().operation == pp::app::DocumentLayerOperation::set_alpha_lock);
        PP_EXPECT(harness, alpha_lock.value().flag);
    }

    const auto blend = pp::app::plan_document_layer_blend_mode(2, 1, 4);
    PP_EXPECT(harness, blend);
    if (blend) {
        PP_EXPECT(harness, blend.value().operation == pp::app::DocumentLayerOperation::set_blend_mode);
        PP_EXPECT(harness, blend.value().blend_mode == 4);
    }

    PP_EXPECT(harness, !pp::app::plan_document_layer_opacity(2, 1, -0.1F));
    PP_EXPECT(harness, !pp::app::plan_document_layer_opacity(2, 1, 1.1F));
    PP_EXPECT(harness, !pp::app::plan_document_layer_opacity(2, 1, std::nanf("")));
    PP_EXPECT(harness, !pp::app::plan_document_layer_blend_mode(2, 1, -1));
    PP_EXPECT(harness, !pp::app::plan_document_layer_blend_mode(2, 1, 5));
    PP_EXPECT(harness, !pp::app::plan_document_layer_visibility(2, 2, true));
    PP_EXPECT(harness, !pp::app::plan_document_layer_alpha_lock(2, 2, true));
}

void layer_highlight_is_transient(pp::tests::Harness& harness)
{
    const auto plan = pp::app::plan_document_layer_highlight(2, 1, true);
    PP_EXPECT(harness, plan);
    if (plan) {
        PP_EXPECT(harness, plan.value().operation == pp::app::DocumentLayerOperation::set_highlight);
        PP_EXPECT(harness, plan.value().flag);
        PP_EXPECT(harness, !plan.value().mutates_document);
        PP_EXPECT(harness, !plan.value().marks_unsaved);
        PP_EXPECT(harness, !plan.value().updates_title);
    }

    PP_EXPECT(harness, !pp::app::plan_document_layer_highlight(2, 2, true));
}

}

int main()
{
    pp::tests::Harness harness;
    harness.run("layer rename records changed name", layer_rename_records_changed_name);
    harness.run("layer rename ignores unchanged name", layer_rename_ignores_unchanged_name);
    harness.run("layer rename rejects empty name", layer_rename_rejects_empty_name);
    harness.run("layer rename rejects overlong name", layer_rename_rejects_overlong_name);
    harness.run("layer add validates insert index and name", layer_add_validates_insert_index_and_name);
    harness.run("layer duplicate select and reorder validate indices", layer_duplicate_select_and_reorder_validate_indices);
    harness.run("layer remove keeps at least one layer", layer_remove_keeps_at_least_one_layer);
    harness.run("layer metadata plans validate values", layer_metadata_plans_validate_values);
    harness.run("layer highlight is transient", layer_highlight_is_transient);
    return harness.finish();
}