1  program tuple_eq_flat_stress.alpha {
  2      struct S {
  3          a: u32,
  4          b: u32,
  5      }
  6  
  7      inline make_pair(x: u32, y: u32) -> (u32, u32) {
  8          return (x, y);
  9      }
 10  
 11      inline make_triple(x: u32, y: u32, z: u32) -> (u32, u32, u32) {
 12          return (x, y, z);
 13      }
 14  
 15      transition test_all() {
 16  
 17          // --- Base tuples
 18          let t1 = (1u32, 2u32);
 19          let t2 = (1u32, 3u32);
 20  
 21          // --- 1. assert_eq / assert_neq on 2-tuples
 22          assert_eq(t1, t1);
 23          assert_neq(t1, t2);
 24  
 25          // --- 2. assert_eq / assert_neq on 3-tuples
 26          let a1 = (5u32, 6u32, 7u32);
 27          let a2 = (5u32, 9u32, 7u32);
 28  
 29          assert_eq(a1, a1);
 30          assert_neq(a1, a2);
 31  
 32          // --- 3. binary == on 2-tuples
 33          let eq1 = t1 == t1;
 34          assert(eq1);
 35  
 36          let eq2 = t1 == t2;
 37          assert(eq2 == false);
 38  
 39          // --- 4. binary != on 2-tuples
 40          let ne1 = t1 != t1;
 41          assert(ne1 == false);
 42  
 43          let ne2 = t1 != t2;
 44          assert(ne2 == true);
 45  
 46          // --- 5. tuple-returning transition: 2-tuple
 47          let p1 = make_pair(10u32, 20u32);
 48          let p2 = make_pair(10u32, 30u32);
 49  
 50          assert_eq(p1, p1);
 51          assert_neq(p1, p2);
 52  
 53          let c1 = p1 == p1;
 54          let c2 = p1 == p2;
 55  
 56          assert(c1 == true);
 57          assert(c2 == false);
 58  
 59          // --- 6. transition returning a flat 3-tuple
 60          let tr1 = make_triple(1u32, 2u32, 3u32);
 61          let tr2 = make_triple(1u32, 4u32, 3u32);
 62  
 63          assert_eq(tr1, tr1);
 64          assert_neq(tr1, tr2);
 65  
 66          let cmp3 = tr1 == tr2;
 67          assert(cmp3 == false);
 68  
 69          // --- 7. tuple comparison in conditionals
 70          if ((1u32, 2u32) == (1u32, 2u32)) {
 71              assert(true);
 72          } else {
 73              assert(false);
 74          }
 75  
 76          if ((1u32, 2u32) != (1u32, 3u32)) {
 77              assert(true);
 78          } else {
 79              assert(false);
 80          }
 81  
 82          // --- 8. tuple built from struct fields
 83          let s1 = S { a: 9u32, b: 8u32 };
 84          let s2 = S { a: 9u32, b: 7u32 };
 85  
 86          assert_eq((s1.a, s1.b), (s1.a, s1.b));
 87          assert_neq((s1.a, s1.b), (s2.a, s2.b));
 88  
 89          // --- 9. long tuple (4 elements)
 90          let long1 = (1u32, 2u32, 3u32, 4u32);
 91          let long2 = (1u32, 2u32, 0u32, 4u32);
 92  
 93          assert_eq(long1, long1);
 94          assert_neq(long1, long2);
 95  
 96          let long_cmp = long1 == long2;
 97          assert(long_cmp == false);
 98  
 99          // --- 10. Direct tuple member accesses on tuple expressions
100          assert((1u32, 2u32).0 == 1u32);
101          assert((1u32, 2u32).1 == 2u32);
102  
103          let x = 42u32;
104          let y = 99u32;
105  
106          assert((x, y).0 == x);
107          assert((x, y).1 == y);
108  
109          // Larger tuple member access
110          let q = (3u32, 4u32, 5u32, 6u32);
111          assert(q.2 == 5u32);
112          assert(q.3 == 6u32);
113  
114          // Member access combined with tuple comparison
115          assert(((x, y).0, (x, y).1) == (x, y));
116          assert_neq(((x, y).0, (x, y).1), (x, x));   // mismatched tuple
117  
118          // --- 11. Ternary selecting between tuples based on tuple comparison
119          let tA = (7u32, 8u32);
120          let tB = (7u32, 9u32);
121  
122          // Condition: tA == tA  → true
123          let sel1 = (tA == tA) ? (1u32, 2u32) : (3u32, 4u32);
124          assert_eq(sel1, (1u32, 2u32));
125  
126          // Condition: tA == tB  → false
127          let sel2 = (tA == tB) ? (10u32, 20u32) : (30u32, 40u32);
128          assert_eq(sel2, (30u32, 40u32));
129  
130          // Condition: comparing tuple expressions directly
131          let sel3 = ((1u32, 2u32) != (1u32, 3u32)) ? (5u32, 6u32) : (7u32, 8u32);
132          assert_eq(sel3, (5u32, 6u32));
133  
134          // Mixed member access + ternary + tuple result
135          let a = 11u32;
136          let b = 22u32;
137          let sel4 = ((a, b).0 == a) ? (a, b) : (0u32, 0u32);
138          assert_eq(sel4, (a, b));
139  
140      }
141  }