RSSuper/linux/src/tests/state-tests.vala

/*
 * StateTests.vala
 * 
 * Unit tests for state management types.
 */

using Gio = Org.Gnome.Valetta.Gio;

public class RSSuper.StateTests {
    
    public static int main(string[] args) {
        var tests = new StateTests();
        
        tests.test_state_enum_values();
        tests.test_state_class_initialization();
        tests.test_state_setters();
        tests.test_state_getters();
        tests.test_state_comparison();
        tests.test_state_signal_emission();
        
        print("All state tests passed!\n");
        return 0;
    }
    
    public void test_state_enum_values() {
        assert(State.IDLE == State.IDLE);
        assert(State.LOADING == State.LOADING);
        assert(State.SUCCESS == State.SUCCESS);
        assert(State.ERROR == State.ERROR);
        
        print("PASS: test_state_enum_values\n");
    }
    
    public void test_state_class_initialization() {
        var state = new State<string>();
        
        assert(state.get_state() == State.IDLE);
        assert(state.is_idle());
        assert(!state.is_loading());
        assert(!state.is_success());
        assert(!state.is_error());
        
        print("PASS: test_state_class_initialization\n");
    }
    
    public void test_state_setters() {
        var state = new State<string>();
        
        // Test set_idle
        state.set_idle();
        assert(state.get_state() == State.IDLE);
        assert(state.is_idle());
        
        // Test set_loading
        state.set_loading();
        assert(state.get_state() == State.LOADING);
        assert(state.is_loading());
        
        // Test set_success
        string data = "test data";
        state.set_success(data);
        assert(state.get_state() == State.SUCCESS);
        assert(state.is_success());
        assert(state.get_data() == data);
        
        // Test set_error
        state.set_error("test error");
        assert(state.get_state() == State.ERROR);
        assert(state.is_error());
        assert(state.get_message() == "test error");
        
        print("PASS: test_state_setters\n");
    }
    
    public void test_state_getters() {
        var state = new State<int>();
        
        // Test initial values
        assert(state.get_state() == State.IDLE);
        assert(state.get_data() == null);
        assert(state.get_message() == null);
        assert(state.get_error() == null);
        
        // Test after set_success
        state.set_success(42);
        assert(state.get_state() == State.SUCCESS);
        assert(state.get_data() == 42);
        assert(state.get_message() == null);
        assert(state.get_error() == null);
        
        // Test after set_error
        state.set_error("database error");
        assert(state.get_state() == State.ERROR);
        assert(state.get_data() == null);
        assert(state.get_message() == "database error");
        assert(state.get_error() != null);
        
        print("PASS: test_state_getters\n");
    }
    
    public void test_state_comparison() {
        var state1 = new State<string>();
        var state2 = new State<string>();
        
        // Initially equal
        assert(state1.get_state() == state2.get_state());
        
        // After different states, not equal
        state1.set_success("value1");
        state2.set_error("error");
        assert(state1.get_state() != state2.get_state());
        
        // Same state, different data
        var state3 = new State<string>();
        state3.set_success("value2");
        assert(state3.get_state() == state1.get_state());
        assert(state3.get_data() != state1.get_data());
        
        print("PASS: test_state_comparison\n");
    }
    
    public void test_state_signal_emission() {
        var state = new State<string>();
        
        // Track signal emissions
        int state_changed_count = 0;
        int data_changed_count = 0;
        
        state.connect_signal("state_changed", (sender, signal) => {
            state_changed_count++;
        });
        
        state.connect_signal("data_changed", (sender, signal) => {
            data_changed_count++;
        });
        
        // Initial state - no signals
        assert(state_changed_count == 0);
        assert(data_changed_count == 0);
        
        // set_loading emits state_changed
        state.set_loading();
        assert(state_changed_count == 1);
        assert(data_changed_count == 0);
        
        // set_success emits both signals
        state.set_success("test");
        assert(state_changed_count == 2);
        assert(data_changed_count == 1);
        
        // set_error emits state_changed only
        state.set_error("error");
        assert(state_changed_count == 3);
        assert(data_changed_count == 1);
        
        print("PASS: test_state_signal_emission\n");
    }
    
    public void test_generic_state_t() {
        // Test State<int>
        var intState = new State<int>();
        intState.set_success(123);
        assert(intState.get_data() == 123);
        assert(intState.is_success());
        
        // Test State<bool>
        var boolState = new State<bool>();
        boolState.set_success(true);
        assert(boolState.get_data() == true);
        assert(boolState.is_success());
        
        // Test State<string>
        var stringState = new State<string>();
        stringState.set_success("hello");
        assert(stringState.get_data() == "hello");
        assert(stringState.is_success());
        
        // Test State<object>
        var objectState = new State<object>();
        objectState.set_success("test");
        assert(objectState.get_data() == "test");
        
        print("PASS: test_generic_state_t\n");
    }
}