strs_tools_meta 0.17.0

Procedural macros for strs_tools compile-time optimizations. Its meta module. Don't use directly.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

//! Integration tests for `optimize_split` macro
//!
//! # Test Matrix for `optimize_split`
//!
//! | Test ID | Scenario | Delimiter Type | Options | Expected Behavior |
//! |---------|----------|----------------|---------|-------------------|
//! | TC1 | Single char delimiter | "," | default | Single char optimization |
//! | TC2 | Multiple char single delim | "->" | default | Multi-char delimiter optimization |
//! | TC3 | Multiple delimiters | `[",", ";"]` | default | Multi-delimiter optimization |
//! | TC4 | Complex delimiters | `[",", "->", " :: "]` | default | Complex pattern fallback |
//! | TC5 | Preserve delimiters | "," | preserve_delimiters=true | Include delimiters in result |
//! | TC6 | Preserve empty | "," | preserve_empty=true | Include empty segments |
//! | TC7 | Multiple delimiters simple | `[",", ";"]` | default | Multi-delimiter optimization |
//! | TC8 | Debug mode | "," | debug | Debug output generated |
//!

#[ cfg( feature = "optimize_split" ) ]
use strs_tools_meta ::optimize_split;

// TC1: Single character delimiter - should use SingleCharDelimiter optimization
#[ cfg( feature = "optimize_split" ) ]
#[ test ]
fn tc1_single_char_delimiter()
{
  let result = optimize_split!( "a,b,c", "," );
  
  // Should generate optimized single character split
  assert_eq!( result.len(), 3 );
  assert_eq!( result[ 0 ], "a" );
  assert_eq!( result[ 1 ], "b" );
  assert_eq!( result[ 2 ], "c" );
}

// TC2: Multiple character single delimiter - should use MultipleCharDelimiters optimization
#[ cfg( feature = "optimize_split" ) ]
#[ test ]
fn tc2_multi_char_single_delimiter()
{
  let result = optimize_split!( "a->b->c", "->" );
  
  // Should generate multi-char delimiter optimization
  assert_eq!( result.len(), 3 );
  assert_eq!( result[ 0 ], "a" );
  assert_eq!( result[ 1 ], "b" );
  assert_eq!( result[ 2 ], "c" );
}

// TC3: Multiple delimiters - should use MultipleCharDelimiters optimization
#[ cfg( feature = "optimize_split" ) ]
#[ test ]
fn tc3_multiple_delimiters()
{
  let result = optimize_split!( "a,b;c", [ ",", ";" ] );
  
  // Should generate multi-delimiter optimization
  assert_eq!( result.len(), 3 );
  assert_eq!( result[ 0 ], "a" );
  assert_eq!( result[ 1 ], "b" );
  assert_eq!( result[ 2 ], "c" );
}

// TC4: Complex delimiters - should use ComplexPattern fallback
#[ cfg( feature = "optimize_split" ) ]
#[ test ]
fn tc4_complex_delimiters()
{
  let result = optimize_split!( "a,b->c ::d", [ ",", "->", " :: " ] );
  
  // Should generate complex pattern fallback
  assert!( result.len() >= 3 );
  assert_eq!( result[ 0 ], "a" );
}

// TC5: Preserve delimiters option
#[ cfg( feature = "optimize_split" ) ]
#[ test ]
fn tc5_preserve_delimiters()
{
  let result = optimize_split!( "a,b,c", ",", preserve_delimiters = true );
  
  // Should include delimiters in result
  assert!( result.len() >= 3 );
  assert_eq!( result[ 0 ], "a" );
}

// TC6: Preserve empty segments option
#[ cfg( feature = "optimize_split" ) ]
#[ test ]
fn tc6_preserve_empty()
{
  let result = optimize_split!( "a,,c", ",", preserve_empty = true );
  
  // Should include empty segments
  assert_eq!( result.len(), 3 );
  assert_eq!( result[ 0 ], "a" );
  assert_eq!( result[ 1 ], "" );
  assert_eq!( result[ 2 ], "c" );
}

// TC7: Multiple delimiters (formerly SIMD disabled test - SIMD parameter removed)
#[ cfg( feature = "optimize_split" ) ]
#[ test ]
fn tc7_multiple_delimiters_simple()
{
  let result = optimize_split!( "a,b;c", [ ",", ";" ] );
  
  // Should use optimized multi-delimiter split
  assert_eq!( result.len(), 3 );
  assert_eq!( result[ 0 ], "a" );
  assert_eq!( result[ 1 ], "b" );
  assert_eq!( result[ 2 ], "c" );
}

// TC8: Debug mode test
// Note: Debug functionality test without console output pollution
#[ cfg( feature = "optimize_split" ) ]
#[ test ]
fn tc8_debug_mode()
{
  let result = optimize_split!( "a,b,c", "," );
  
  assert_eq!( result.len(), 3 );
  assert_eq!( result[ 0 ], "a" );
  assert_eq!( result[ 1 ], "b" );
  assert_eq!( result[ 2 ], "c" );
}

// Test for explicit parameter values to avoid fragile tests
#[ cfg( feature = "optimize_split" ) ]
#[ test ]
fn tc9_explicit_parameters()
{
  let result = optimize_split!(
  "a,b,c",
  ",",
  preserve_delimiters = false,
  preserve_empty = false
 );
  
  assert_eq!( result.len(), 3 );
  assert_eq!( result[ 0 ], "a" );
  assert_eq!( result[ 1 ], "b" );
  assert_eq!( result[ 2 ], "c" );
}

// Test default value equivalence - dedicated test for parameter defaults
#[ cfg( feature = "optimize_split" ) ]
#[ test ]
fn tc10_default_value_equivalence()
{
  let result_explicit = optimize_split!(
  "a,b,c",
  ",",
  preserve_delimiters = false,
  preserve_empty = false
 );
  
  let result_default = optimize_split!( "a,b,c", "," );
  
  // Results should be equivalent
  assert_eq!( result_explicit, result_default );
}