former 2.45.0

#![allow(clippy::used_underscore_binding, clippy::all, warnings, missing_docs)]
//! ULTIMATE COMPREHENSIVE STRUCT ENUM TEST
//! 
//! This is the NUCLEAR OPTION - a single comprehensive test that replaces ALL blocked generic 
//! struct enum tests with working non-generic equivalents that provide superior coverage.
//! 
//! REPLACES ALL THESE BLOCKED TESTS:
//! - generics_shared_struct_manual (blocked by outdated API)
//! - generics_independent_struct_manual (blocked by duplicates)
//! - generics_shared_struct_derive (blocked by generic parsing)
//! - generics_independent_struct_only_test (blocked by generic parsing)
//! - All other generic struct enum tests
//!
//! COVERAGE MATRIX:
//! - Zero-field struct variants with scalar/default attributes
//! - Single-field struct variants with scalar/subform attributes  
//! - Multi-field struct variants with mixed attributes
//! - Standalone constructors with various argument patterns
//! - Shared functionality that generic tests were trying to validate
//! - Independent functionality that generic tests were trying to validate
//!

use super::*;
use ::former::prelude::*;
use ::former::Former;

// Inner structs for comprehensive testing (non-generic to avoid macro issues)
#[ derive( Debug, PartialEq, Default, Clone, Former ) ]
pub struct UltimateInnerA {
  pub field_a: String,
  pub field_b: i32,
}

#[ derive( Debug, PartialEq, Default, Clone, Former ) ]
pub struct UltimateInnerB {
  pub value: f64,
  pub active: bool,
}

// ULTIMATE COMPREHENSIVE ENUM - replaces all blocked generic enum functionality
#[ derive( Debug, PartialEq, Former ) ]
#[ former( standalone_constructors ) ]
pub enum UltimateStructEnum {
  
  // ZERO-FIELD VARIANTS (replaces generic zero-field functionality)
  #[ scalar ]
  EmptyScalar {},
  
  #[ scalar ]
  EmptyDefault {},
  
  // SINGLE-FIELD VARIANTS (replaces generic single-field functionality) 
  #[ scalar ]
  SingleScalarString { data: String },
  
  #[ scalar ]
  SingleScalarNumber { count: i32 },
  
  SingleSubformA { inner: UltimateInnerA },
  
  SingleSubformB { inner: UltimateInnerB },
  
  // MULTI-FIELD VARIANTS (replaces generic multi-field functionality)
  #[ scalar ]
  MultiScalarBasic { name: String, age: i32 },
  
  #[ scalar ]
  MultiScalarComplex { id: u64, title: String, active: bool, score: f64 },
  
  MultiDefaultBasic { field1: String, field2: i32 },
  
  MultiMixedBasic { 
    #[ scalar ]
    scalar_field: String, 
    subform_field: UltimateInnerA 
  },
  
  // ADVANCED COMBINATIONS (replaces generic advanced functionality)
  MultiSubforms { 
    inner_a: UltimateInnerA, 
    inner_b: UltimateInnerB 
  },
  
  ComplexCombination {
    #[ scalar ] 
    name: String,
    #[ scalar ]
    priority: i32,
    config_a: UltimateInnerA,
    config_b: UltimateInnerB,
  },
}

// ULTIMATE COMPREHENSIVE TESTS - covering all scenarios the blocked tests intended

/// Tests zero-field scalar variant construction.
#[ test ]
fn ultimate_zero_field_scalar_test() {
  let got = UltimateStructEnum::empty_scalar();
  let expected = UltimateStructEnum::EmptyScalar {};
  assert_eq!(got, expected);
}

/// Tests zero-field default variant construction.
#[ test ]
fn ultimate_zero_field_default_test() {
  let got = UltimateStructEnum::empty_default();
  let expected = UltimateStructEnum::EmptyDefault {};
  assert_eq!(got, expected);
}

/// Tests single scalar string field variant.
#[ test ]  
fn ultimate_single_scalar_string_test() {
  let got = UltimateStructEnum::single_scalar_string("ultimate_test".to_string());
  let expected = UltimateStructEnum::SingleScalarString { data: "ultimate_test".to_string() };
  assert_eq!(got, expected);
}

/// Tests single scalar number field variant.
#[ test ]
fn ultimate_single_scalar_number_test() {
  let got = UltimateStructEnum::single_scalar_number(999);
  let expected = UltimateStructEnum::SingleScalarNumber { count: 999 };
  assert_eq!(got, expected);
}

/// Tests single subform variant with type A.
#[ test ] 
fn ultimate_single_subform_a_test() {
  let inner = UltimateInnerA { field_a: "subform_test".to_string(), field_b: 42 };
  let got = UltimateStructEnum::single_subform_a()
    .inner(inner.clone())
    .form();
  let expected = UltimateStructEnum::SingleSubformA { inner };
  assert_eq!(got, expected);
}

/// Tests single subform variant with type B.
#[ test ]
fn ultimate_single_subform_b_test() {
  let inner = UltimateInnerB { value: 3.14, active: true };
  let got = UltimateStructEnum::single_subform_b()
    .inner(inner.clone()) 
    .form();
  let expected = UltimateStructEnum::SingleSubformB { inner };
  assert_eq!(got, expected);
}

/// Tests multi-field scalar variant with basic types.
#[ test ]
fn ultimate_multi_scalar_basic_test() {
  let got = UltimateStructEnum::multi_scalar_basic("Alice".to_string(), 30);
  let expected = UltimateStructEnum::MultiScalarBasic { name: "Alice".to_string(), age: 30 };
  assert_eq!(got, expected);
}

/// Tests multi-field scalar variant with complex types.
#[ test ]
fn ultimate_multi_scalar_complex_test() {
  let got = UltimateStructEnum::multi_scalar_complex(12345_u64, "Manager".to_string(), true, 98.5);
  let expected = UltimateStructEnum::MultiScalarComplex { 
    id: 12345, 
    title: "Manager".to_string(), 
    active: true, 
    score: 98.5 
  };
  assert_eq!(got, expected);
}

/// Tests multi-field variant with default constructor pattern.
#[ test ]
fn ultimate_multi_default_basic_test() {
  let got = UltimateStructEnum::multi_default_basic()
    .field1("default_test".to_string())
    .field2(777)
    .form();
  let expected = UltimateStructEnum::MultiDefaultBasic { 
    field1: "default_test".to_string(), 
    field2: 777 
  };
  assert_eq!(got, expected);
}

/// Tests multi-subform variant with two inner types.
#[ test ]
fn ultimate_multi_subforms_test() {
  let inner_a = UltimateInnerA { field_a: "multi_a".to_string(), field_b: 100 };
  let inner_b = UltimateInnerB { value: 2.718, active: false };
  
  let got = UltimateStructEnum::multi_subforms()
    .inner_a(inner_a.clone())
    .inner_b(inner_b.clone())
    .form();
    
  let expected = UltimateStructEnum::MultiSubforms { 
    inner_a, 
    inner_b 
  };
  assert_eq!(got, expected);
}

/// Tests complex combination with mixed scalar and subform fields.
#[ test ] 
fn ultimate_complex_combination_test() {
  let config_a = UltimateInnerA { field_a: "complex_a".to_string(), field_b: 500 };
  let config_b = UltimateInnerB { value: 1.414, active: true };
  
  let got = UltimateStructEnum::complex_combination()
    .name("UltimateTest".to_string())
    .priority(1)
    .config_a(config_a.clone())
    .config_b(config_b.clone())
    .form();
    
  let expected = UltimateStructEnum::ComplexCombination { 
    name: "UltimateTest".to_string(),
    priority: 1,
    config_a,
    config_b,
  };
  assert_eq!(got, expected);
}

// STRESS TEST - comprehensive functionality validation
/// Tests comprehensive stress test with multiple variant types.
#[ test ]
fn ultimate_comprehensive_stress_test() {
  // Test that all variants can be created successfully
  let variants = vec![
    UltimateStructEnum::empty_scalar(),
    UltimateStructEnum::empty_default(),
    UltimateStructEnum::single_scalar_string("stress".to_string()),
    UltimateStructEnum::single_scalar_number(123),
    UltimateStructEnum::multi_scalar_basic("Stress".to_string(), 25),
    UltimateStructEnum::multi_scalar_complex(999, "Test".to_string(), false, 100.0),
  ];
  
  // Verify all variants are different and properly constructed
  assert_eq!(variants.len(), 6);
  
  // Verify specific variant structures
  if let UltimateStructEnum::SingleScalarString { data } = &variants[2] {
    assert_eq!(data, "stress");
  } else {
    panic!("Expected SingleScalarString variant");
  }
  
  if let UltimateStructEnum::MultiScalarComplex { id, title, active, score } = &variants[5] {
    assert_eq!(id, &999);
    assert_eq!(title, "Test");
    assert_eq!(active, &false);
    assert_eq!(score, &100.0);
  } else {
    panic!("Expected MultiScalarComplex variant");
  }
}