former : tests purpose

Author: Wandalen

module/core/former/plan.md

@@ -1,30 +1,25 @@
 //! Purpose: Provides shared test assertions and logic for verifying the constructors generated
 //! by `#[derive(Former)]` for enums with unnamed (tuple) variants that have shared generic
-//! parameters and bounds, using the default subform behavior. This file is included by both
-//! `generics_in_tuple_variant_tuple_derive.rs` and `generics_in_tuple_variant_tuple_manual.rs`.
+//! parameters and bounds. This file is included by both `generics_in_tuple_variant_tuple_derive.rs`
+//! and `generics_in_tuple_variant_tuple_manual.rs`. It also contains tests for unit variants
+//! within a generic enum, included by `generics_in_tuple_variant_unit_derive.rs` and
+//! `generics_in_tuple_variant_unit_manual.rs`.
 //!
 //! Coverage:
 //! - Rule 3d (Tuple + Single-Field + Default -> Subform): Tests static method `EnumOuter::<X>::variant()`.
 //! - Rule 4b (Option 2 Logic): Tests the use of subformer methods and `.form()`.
+//! - Rule 3a (Unit + Default): Tests static method `EnumOuter::<X>::other_variant()`.
+//! - Rule 1a (Unit + `#[scalar]`): Tests static method `EnumOuter::<X>::other_variant()` (as default for unit is scalar).
 //!
 //! Test Relevance/Acceptance Criteria:
 //! - Defines dummy bounds (`BoundA`, `BoundB`) and concrete types (`TypeForT`, `TypeForU`) that satisfy them.
-//! - Defines test functions (`basic_construction`, `construction_with_bounds`) that invoke the static method
-//!   `EnumOuter::<X>::variant()` provided by the including file (either derived or manual).
-//! - This constructor returns a subformer (`InnerGenericFormer<X>`).
-//! - The tests use the subformer setter (`.inner_field()`) and `.form()` to build the final enum instance.
+//! - Defines test functions (`basic_construction`, `construction_with_bounds`, `unit_variant_generics`) that invoke the static methods
+//!   (`EnumOuter::<X>::variant()`, `EnumOuter::<X>::other_variant()`) provided by the including file (either derived or manual).
+//! - For tuple variants, the constructor returns a subformer (`InnerGenericFormer<X>`). The tests use the subformer setter (`.inner_field()`) and `.form()` to build the final enum instance.
+//! - For unit variants, the constructor directly returns the enum instance.
 //! - Asserts that the resulting `EnumOuter` enum instances are equal to the expected variants
-//!   (`EnumOuter::Variant(InnerGeneric { ... })`), confirming correct handling of shared generics and bounds.
-//! Test logic for enum variants with independent generic parameters.
-//!
-//! Purpose:
-//! - Define `EnumG5<T: BoundA>` and `InnerG5<U: BoundB>` with independent generics.
-//! - Apply `#[derive(Former)]` to both the enum and the inner struct.
-//! - Use the included `_only_test.rs` file to verify that the macro-generated code
-//!   correctly handles the distinct generics `T` and `U` (instantiated as `TypeForU`
-//!   in the variant) and their respective bounds.
-//!
-// File: module/core/former/tests/inc/former_enum_tests/generics_in_tuple_variant_only_test.rs
+//!   (`EnumOuter::Variant(InnerGeneric { ... })`, `EnumOuter::OtherVariant`), confirming correct handling of shared generics and bounds for both tuple and unit variants.
+//! - Verifies that the bounds (`Copy`, `Debug`, `Default`, `PartialEq`) are correctly handled by using types that satisfy them.
 #[ allow( unused_imports ) ]
 use super::*; // Should import EnumOuter and InnerGeneric from either the manual or derive file
 use std::fmt::Debug; // Removed redundant import (E0252 fix)
@@ -76,6 +71,22 @@ fn construction_with_bounds()
   assert_eq!( got, expected );
 }
 
+#[ test ]
+fn unit_variant_generics()
+{
+  // Test the unit variant constructor within the generic enum
+  // Uses a concrete type that satisfies the enum's bounds
+  #[ derive( Debug, Copy, Clone, PartialEq ) ]
+  struct MyType;
+  impl Default for MyType { fn default() -> Self { Self } } // Added Default for EnumOuter bounds
+
+  let got = EnumOuter::< MyType >::other_variant(); // Assuming this constructor exists
+
+  let expected = EnumOuter::< MyType >::OtherVariant; // Assuming this variant exists
+
+  assert_eq!( got, expected );
+}
+
 // Optional: Add a test that *should* fail compilation if bounds are not met.
 // This requires a compile-fail test setup (like trybuild), which is outside
 // the scope of just adding files here.

module/core/former/tests/inc/enum_unnamed_tests/generics_in_tuple_variant_only_test.rs

@@ -4,16 +4,15 @@
 //!
 //! Coverage:
 //! - Rule 3d (Tuple + Single-Field + Default -> Subform): Verifies `EnumOuter::<X>::variant() -> InnerGenericFormer<X>`.
-//! - Rule 4a (#[standalone_constructors]): Verifies generation of top-level constructor functions (though not explicitly tested in `_only_test.rs`).
+//! - Rule 4b (Option 2 Logic): Verifies the use of the subformer returned by the variant constructor.
 //!
 //! Test Relevance/Acceptance Criteria:
-//! - Defines a generic enum `EnumOuter<X: Copy>` with a single-field tuple variant `Variant(InnerGeneric<X>)`.
-//! - The inner struct `InnerGeneric<T: Debug + Copy>` has its own generic `T` and bounds, and is instantiated with the enum's generic `X` in the variant.
+//! - Defines a generic enum `EnumOuter<X: Copy + Debug + Default + PartialEq>` with a single-field tuple variant `Variant(InnerGeneric<X>)`.
+//! - The inner struct `InnerGeneric<T: Debug + Copy + Default + PartialEq>` has its own generic `T` and bounds, and is instantiated with the enum's generic `X` in the variant.
 //! - The enum has `#[derive(Former)]` and `#[debug]`.
-//! - Relies on the derived static method `EnumOuter::<X>::variant()` defined in `generics_in_tuple_variant_only_test.rs`.
+//! - Relies on the derived static method `EnumOuter::<X>::variant()` provided by this file (via `include!`).
 //! - Asserts that this constructor returns the expected subformer (`InnerGenericFormer<X>`) and that using the subformer's setter (`.inner_field()`) and `.form()` results in the correct `EnumOuter` enum instance.
-//! - Verifies that the bounds (`Copy`, `Debug`, `PartialEq`, `Default`) are correctly handled by using types that satisfy them.
-// File: module/core/former/tests/inc/former_enum_tests/unnamed_tests/generics_in_tuple_variant_tuple_derive.rs
+//! - Verifies that the bounds (`Copy`, `Debug`, `Default`, `PartialEq`) are correctly handled by using types that satisfy them.
 #[ allow( unused_imports ) ]
 use super::*; // Imports testing infrastructure and potentially other common items
 use std::fmt::Debug; // Import Debug trait for bounds
@@ -22,13 +21,13 @@ use std::marker::PhantomData; // Import PhantomData
 // --- Inner Struct Definition with Bounds ---
 // Needs to derive Former for the enum's derive to work correctly for subforming.
 #[derive(Debug, PartialEq, Clone, Copy, former::Former)] // Added Former derive
-pub struct InnerGeneric< T : Debug + Copy > // Added Copy bound here too
+pub struct InnerGeneric< T : Debug + Copy + Default + PartialEq > // Added Copy bound here too
 {
   pub inner_field : T,
 }
 
 // Implement Into manually for testing the constructor signature
-impl< T : Debug + Copy > From< T > for InnerGeneric< T >
+impl< T : Debug + Copy + Default + PartialEq > From< T > for InnerGeneric< T >
 {
   fn from( data : T ) -> Self { Self { inner_field : data } }
 }
@@ -37,7 +36,7 @@ impl< T : Debug + Copy > From< T > for InnerGeneric< T >
 // Apply Former derive here. This is what we are testing.
 #[derive(Debug, PartialEq, former::Former)]
 #[debug]
-pub enum EnumOuter< X : Copy > // Enum bound: Copy
+pub enum EnumOuter< X : Copy + Debug + Default + PartialEq > // Enum bound: Copy
 {
   // --- Tuple Variant with Generics ---
   Variant( InnerGeneric< X > ), // Inner type uses X, which must satisfy InnerGeneric's bounds (Debug + Copy)

module/core/former/tests/inc/enum_unnamed_tests/generics_in_tuple_variant_tuple_derive.rs

@@ -8,30 +8,13 @@
 //! - Rule 4b (Option 2 Logic): Manual implementation of `FormingEnd` for the variant end type.
 //!
 //! Test Relevance/Acceptance Criteria:
-//! - Defines a generic enum `EnumOuter<X: Copy>` with a single-field tuple variant `Variant(InnerGeneric<X>)`.
+//! - Defines a generic enum `EnumOuter<X: Copy + Debug + Default + PartialEq>` with a single-field tuple variant `Variant(InnerGeneric<X>)`.
 //! - The inner struct `InnerGeneric<T: Debug + Copy + Default + PartialEq>` has its own generic `T` and bounds,
 //!   and is instantiated with the enum's generic `X` in the variant.
 //! - Manually implements a static method `EnumOuter::variant()` that mirrors the expected generated code for a subform variant.
 //! - Manually implements `FormingEnd` for the end type associated with the variant subformer.
 //! - This file is included by `generics_in_tuple_variant_only_test.rs` to provide the manual implementations
 //!   that the shared tests compare against.
-//! Manual implementation for testing enum variants with independent generic parameters.
-//!
-//! Purpose:
-//! - Define an enum `EnumG5<T: BoundA>` where `T` is the enum's generic.
-//! - Define an inner struct `InnerG5<U: BoundB>` where `U` is the inner struct's generic.
-//! - Define a variant `V1(InnerG5<TypeForU>, PhantomData<T>)` where `U` is instantiated with a specific
-//!   concrete type (`TypeForU`) that satisfies `BoundB`, while `T` remains generic for the enum.
-//!   `PhantomData<T>` is added to ensure the `T` parameter is used.
-//! - Manually implement the `Former` logic (static method `v1`, `End` struct, `impl FormingEnd`)
-//!   to ensure the distinct generics `T` and `U` (instantiated as `TypeForU`) and their bounds
-//!   are handled correctly. The static method `v1` should be generic over `T`, while the
-//!   returned former and the `End` logic operate on the concrete `InnerG5<TypeForU>`.
-//!
-//! This setup tests the macro's ability to handle scenarios where the enum's state (`T`)
-//! is independent of the specific type (`TypeForU`) being formed within one of its variants.
-//!
-// File: module/core/former/tests/inc/former_enum_tests/unnamed_tests/generics_in_tuple_variant_tuple_manual.rs
 #[ allow( unused_imports ) ]
 use super::*; // Imports testing infrastructure and potentially other common items
 use std::fmt::Debug; // Import Debug trait for bounds

module/core/former/tests/inc/enum_unnamed_tests/generics_in_tuple_variant_tuple_manual.rs

@@ -10,18 +10,8 @@
 //! - Defines a generic enum `EnumG5<T: BoundA>` with a single-field tuple variant `V1(InnerG5<TypeForU>, PhantomData<T>)`.
 //! - The inner struct `InnerG5<U: BoundB>` has its own generic `U` and bound `BoundB`, and is instantiated with a concrete `TypeForU` in the variant.
 //! - The variant `V1` is annotated with `#[scalar]`. The enum has `#[derive(Former)]`.
-//! - Relies on the derived static method `EnumG5::<TypeForT>::v1()` defined in `generics_independent_tuple_only_test.rs`.
+//! - Relies on the derived static method `EnumG5::<TypeForT>::v_1()` defined in `generics_independent_tuple_only_test.rs`.
 //! - Asserts that this constructor produces the correct `EnumG5` enum instance by comparing with a manually constructed variant, confirming correct handling of independent generics and the `#[scalar]` attribute.
-//! Derive-based test for enum variants with independent generic parameters.
-//!
-//! Purpose:
-//! - Define `EnumG5<T: BoundA>` and `InnerG5<U: BoundB>` with independent generics.
-//! - Apply `#[derive(Former)]` to both the enum and the inner struct.
-//! - Use the included `_only_test.rs` file to verify that the macro-generated code
-//!   correctly handles the distinct generics `T` and `U` (instantiated as `TypeForU`
-//!   in the variant) and their respective bounds.
-//!
-// File: module/core/former/tests/inc/former_enum_tests/generics_independent_tuple_derive.rs
 use super::*; // Imports testing infrastructure and potentially other common items
 use std::marker::PhantomData;
 

module/core/former/tests/inc/enum_unnamed_tests/generics_independent_tuple_derive.rs

@@ -4,7 +4,6 @@
 //!
 //! Coverage:
 //! - Rule 1d (Tuple + Single-Field + `#[scalar]` -> Scalar): Manual implementation of static method `EnumG5::v_1()`.
-//! - Rule 4a (#[standalone_constructors]): Not applicable to this manual implementation file.
 //! - Rule 4b (Option 2 Logic): Manual implementation of `FormingEnd` for the variant end type.
 //!
 //! Test Relevance/Acceptance Criteria:
@@ -13,23 +12,6 @@
 //! - Manually implements `FormingEnd` for the end type associated with the variant subformer.
 //! - This file is included by `generics_independent_tuple_only_test.rs` to provide the manual implementations
 //!   that the shared tests compare against.
-//! Manual implementation for testing enum variants with independent generic parameters.
-//!
-//! Purpose:
-//! - Define an enum `EnumG5<T: BoundA>` where `T` is the enum's generic.
-//! - Define an inner struct `InnerG5<U: BoundB>` where `U` is the inner struct's generic.
-//! - Define a variant `V1(InnerG5<TypeForU>, PhantomData<T>)` where `U` is instantiated with a specific
-//!   concrete type (`TypeForU`) that satisfies `BoundB`, while `T` remains generic for the enum.
-//!   `PhantomData<T>` is added to ensure the `T` parameter is used.
-//! - Manually implement the `Former` logic (static method `v1`, `End` struct, `impl FormingEnd`)
-//!   to ensure the distinct generics `T` and `U` (instantiated as `TypeForU`) and their bounds
-//!   are handled correctly. The static method `v1` should be generic over `T`, while the
-//!   returned former and the `End` logic operate on the concrete `InnerG5<TypeForU>`.
-//!
-//! This setup tests the macro's ability to handle scenarios where the enum's state (`T`)
-//! is independent of the specific type (`TypeForU`) being formed within one of its variants.
-//!
-// File: module/core/former/tests/inc/former_enum_tests/generics_independent_tuple_manual.rs
 use super::*; // Imports testing infrastructure and potentially other common items
 use std::marker::PhantomData;
 use former_types::

module/core/former/tests/inc/enum_unnamed_tests/generics_independent_tuple_manual.rs

@@ -4,7 +4,7 @@
 //! This file is included by both `generics_independent_tuple_derive.rs` and `generics_independent_tuple_manual.rs`.
 //!
 //! Coverage:
-//! - Rule 1d (Tuple + Single-Field + `#[scalar]` -> Scalar): Tests static method `EnumG5::<T>::v1()`.
+//! - Rule 1d (Tuple + Single-Field + `#[scalar]` -> Scalar): Tests static method `EnumG5::<T>::v_1()`.
 //! - Rule 4b (Option 2 Logic): Tests the use of subformer methods and `.form()`.
 //!
 //! Test Relevance/Acceptance Criteria:
@@ -15,16 +15,6 @@
 //! - The tests use the subformer setter (`._0()`) and `.form()` to build the final enum instance.
 //! - Asserts that the resulting `EnumG5` enum instances are equal to the expected variants
 //!   (`EnumG5::V1(InnerG5 { ... }, PhantomData)`), confirming correct handling of independent generics and the `#[scalar]` attribute.
-//! Test logic for enum variants with independent generic parameters.
-//!
-//! Purpose:
-//! - Define `EnumG5<T: BoundA>` and `InnerG5<U: BoundB>` with independent generics.
-//! - Apply `#[derive(Former)]` to both the enum and the inner struct.
-//! - Use the included `_only_test.rs` file to verify that the macro-generated code
-//!   correctly handles the distinct generics `T` and `U` (instantiated as `TypeForU`
-//!   in the variant) and their respective bounds.
-//!
-// File: module/core/former/tests/inc/former_enum_tests/generics_independent_tuple_only_test.rs
 use super::*; // Imports items from the parent file (either manual or derive)
 // Define dummy bounds for testing purposes
 pub trait BoundA : core::fmt::Debug + Default + Clone + PartialEq {}

module/core/former/tests/inc/enum_unnamed_tests/generics_independent_tuple_only_test.rs

@@ -1,4 +1,19 @@
-// File: module/core/former/tests/inc/former_enum_tests/generics_shared_tuple_derive.rs
+//! Purpose: Tests the `#[derive(Former)]` macro's generation of constructors for unnamed (tuple)
+//! variants with shared generic parameters and bounds, using the default subform behavior.
+//! This file focuses on verifying the derive-based implementation.
+//!
+//! Coverage:
+//! - Rule 3d (Tuple + Single-Field + Default -> Subform): Verifies `EnumG3::<T>::v1() -> InnerG3Former<T>`.
+//! - Rule 4b (Option 2 Logic): Verifies the use of the subformer returned by the variant constructor.
+//!
+//! Test Relevance/Acceptance Criteria:
+//! - Defines a generic enum `EnumG3<T: BoundA + BoundB>` with a single-field tuple variant `V1(InnerG3<T>)`.
+//! - The inner struct `InnerG3<T: BoundB>` has its own generic `T` and bound `BoundB`, and is instantiated with the enum's generic `T` in the variant.
+//! - The enum has `#[derive(Former)]`.
+//! - Relies on the derived static method `EnumG3::<T>::v_1()` provided by this file (via `include!`).
+//! - Asserts that this constructor returns the expected subformer (`InnerG3Former<T>`) and that using the subformer's setter (`.inner_field()`) and `.form()` results in the correct `EnumG3` enum instance.
+//! - Verifies that the bounds (`BoundA`, `BoundB`) are correctly handled by using a type that satisfies both.
+#[ allow( unused_imports ) ]
 use super::*; // Imports testing infrastructure and potentially other common items
 
 // --- Dummy Bounds ---

module/core/former/tests/inc/enum_unnamed_tests/generics_shared_tuple_derive.rs

@@ -1,4 +1,20 @@
-// File: module/core/former/tests/inc/former_enum_tests/generics_shared_tuple_manual.rs
+//! Purpose: Provides a manual implementation of constructors and `FormingEnd` for an enum
+//! with unnamed (tuple) variants that have shared generic parameters and bounds, using the
+//! default subform behavior, to serve as a reference for verifying the `#[derive(Former)]`
+//! macro's behavior.
+//!
+//! Coverage:
+//! - Rule 3d (Tuple + Single-Field + Default -> Subform): Manual implementation of static method `EnumG3::v_1()`.
+//! - Rule 4b (Option 2 Logic): Manual implementation of `FormingEnd` for the variant end type.
+//!
+//! Test Relevance/Acceptance Criteria:
+//! - Defines a generic enum `EnumG3<T: BoundA + BoundB>` with a single-field tuple variant `V1(InnerG3<T>)`.
+//! - The inner struct `InnerG3<T: BoundB>` has its own generic `T` and bound `BoundB`, and is instantiated with the enum's generic `T` in the variant.
+//! - Manually implements a static method `EnumG3::v_1()` that mirrors the expected generated code for a subform variant.
+//! - Manually implements `FormingEnd` for the end type associated with the variant subformer.
+//! - This file is included by `generics_shared_tuple_only_test.rs` to provide the manual implementations
+//!   that the shared tests compare against.
+#[ allow( unused_imports ) ]
 use super::*; // Imports testing infrastructure and potentially other common items
 use std::marker::PhantomData;
 use former_types::
@@ -103,7 +119,7 @@ where Definition : FormerDefinition< Storage = InnerG3FormerStorage< T > >
 // --- Enum Definition with Bounds ---
 #[ derive( Debug, PartialEq, Clone ) ]
 // CORRECTED: Added BoundB to the enum's generic constraint for T
-pub enum EnumG3< T : BoundA + BoundB > // BoundA required by the enum, BoundB required by InnerG3<T>
+pub enum EnumG3< T : BoundA + BoundB > // BoundA required by enum, BoundB required by InnerG3<T>
 {
   V1( InnerG3< T > ), // Inner type uses T, so T must satisfy InnerG3's bounds (BoundB) *in addition* to EnumG3's bounds (BoundA)
 }