Changeset cb344f7 for tests/concurrency

Timestamp:

Jul 18, 2023, 9:31:57 AM (17 months ago)

Author:

caparsons <caparson@…>

Branches:

master

Children:

ca22a7c

Parents:

a1467c1

Message:

refactored tests to use new syntax for channel ops

Location:

tests/concurrency

Files:

• channels/daisy_chain.cfa (modified) (2 diffs)
• waituntil/all_types.cfa (modified) (1 diff)
• waituntil/channel_close.cfa (modified) (1 diff)
• waituntil/channel_zero_size.cfa (modified) (1 diff)
• waituntil/channels.cfa (modified) (1 diff)
• waituntil/one_chan.cfa (modified) (1 diff)
• waituntil/repeat_close.cfa (modified) (2 diffs)

tests/concurrency/channels/daisy_chain.cfa

@@ -23 +23 @@
         for ( ;; ) {
             token << *chain;
-            token >> *chain;
+            *chain << token;
             runs++;
         }
@@ -60 +60 @@
     Channel chainChan{ 1 };
 
-    ((int)0) >> chainChan;
+    chainChan << ((int)0);
 
     chain = &chainChan;    

tests/concurrency/waituntil/all_types.cfa

@@ -96 +96 @@
             Churner c;
             for( long long int j = 0; j < numtimes; j++ ) {
-                when( j % 2 == 0 ) waituntil( j >> A ) { total += j; }
+                when( j % 2 == 0 ) waituntil( A << j ) { total += j; }
                 or when( j % 4 < 2 ) waituntil( B ) { produce_b_val( total ); }
-                and when( j % 8 < 4 ) waituntil( j >> C ) { total += j; }
+                and when( j % 8 < 4 ) waituntil( C << j ) { total += j; }
                 and waituntil( timeout( 1`ns ) ) {}
                 if ( j == numtimes / 2 )

tests/concurrency/waituntil/channel_close.cfa

@@ -13 +13 @@
     try {
         for( long long int i = 0;;i++ ) {
-            waituntil( (i >> A) ) { inserts++; }
-            and waituntil( (i >> B) ) { inserts++; }
+            waituntil( A << i ) { inserts++; }
+            and waituntil( B << i ) { inserts++; }
         }
     } catch ( channel_closed * e ) {} 

tests/concurrency/waituntil/channel_zero_size.cfa

@@ -37 +37 @@
         for( long long int j = 0; j < numtimes; j++ ) {
             // printf("loop\n");
-            waituntil( j >> A ) { total += j; }
-            or waituntil( j >> B ) { total += j; }
-            or waituntil( j >> C ) { total += j; }
+            waituntil( A << j ) { total += j; }
+            or waituntil( B << j ) { total += j; }
+            or waituntil( C << j ) { total += j; }
         }
         printf("sending sentinels\n");

tests/concurrency/waituntil/channels.cfa

@@ -69 +69 @@
             Churner c;
             for( long long int j = 0; j < numtimes; j++ ) {
-                when( j % 2 == 0 ) waituntil( j >> A ) { total += j; }
-                or when( j % 4 < 2 ) waituntil( j >> B ) { total += j; }
-                and when( j % 8 < 4 ) waituntil( j >> C ) { total += j; }
+                when( j % 2 == 0 ) waituntil( A << j ) { total += j; }
+                or when( j % 4 < 2 ) waituntil( B << j ) { total += j; }
+                and when( j % 8 < 4 ) waituntil( C << j ) { total += j; }
             }
             done = true;

tests/concurrency/waituntil/one_chan.cfa

@@ -31 +31 @@
         Server1 s[numServers];
         for( long long int j = 0; j < numtimes; j++ ) {
-            waituntil( j >> C ) { total += j; }
+            waituntil( C << j ) { total += j; }
         }
         printf("waiting for empty channels\n");

tests/concurrency/waituntil/repeat_close.cfa

@@ -15 +15 @@
     try {
         for( long long int i = 0;;i++ ) {
-            waituntil( (i >> A) ) { A_i++; }
-            and waituntil( (i >> B) ) { B_i++; }
-            and waituntil( (i >> C) ) { C_i++; }
-            and waituntil( (i >> D) ) { D_i++; }
-            and waituntil( (i >> E) ) { E_i++; }
-            and waituntil( (i >> F) ) { F_i++; }
+            waituntil( A << i ) { A_i++; }
+            and waituntil( B << i ) { B_i++; }
+            and waituntil( C << i ) { C_i++; }
+            and waituntil( D << i ) { D_i++; }
+            and waituntil( E << i ) { E_i++; }
+            and waituntil( F << i ) { F_i++; }
         }
     } catch ( channel_closed * e ) {} 
@@ -31 +31 @@
     try {
         for( ;; ) {
-            waituntil( remove(F) ) { F_removes++; }
-            or waituntil( remove(E) ) { E_removes++; }
-            or waituntil( remove(D) ) { D_removes++; }
-            or waituntil( remove(C) ) { C_removes++; }
-            or waituntil( remove(B) ) { B_removes++; }
-            or waituntil( remove(A) ) { A_removes++; }
+            waituntil( in << F ) { F_removes++; }
+            or waituntil( in << E ) { E_removes++; }
+            or waituntil( in << D ) { D_removes++; }
+            or waituntil( in << C ) { C_removes++; }
+            or waituntil( in << B ) { B_removes++; }
+            or waituntil( in << A ) { A_removes++; }
         }
     } catchResume ( channel_closed * e ) { } // continue to remove until would block