Parsed test spec with 2 sessions

starting permutation: s0_update_l s1_tuplock_l_0 s0_commit s1_commit
step s0_update_l: UPDATE l SET i = i + 1;
step s1_tuplock_l_0: 
    EXPLAIN (VERBOSE, COSTS OFF)
    SELECT l.* FROM l, ft WHERE l.i = ft.i AND l.i = 123 FOR UPDATE OF l;
    SELECT l.* FROM l, ft WHERE l.i = ft.i AND l.i = 123 FOR UPDATE OF l;
 <waiting ...>
step s0_commit: COMMIT;
step s1_tuplock_l_0: <... completed>
QUERY PLAN                                                           
---------------------------------------------------------------------
LockRows                                                             
  Output: l.i, l.v, l.ctid, ft.*                                     
  ->  Nested Loop                                                    
        Output: l.i, l.v, l.ctid, ft.*                               
        ->  Seq Scan on public.l                                     
              Output: l.i, l.v, l.ctid                               
              Filter: (l.i = 123)                                    
        ->  Foreign Scan on public.ft                                
              Output: ft.*, ft.i                                     
              Remote SQL: SELECT i, v FROM public.t WHERE ((i = 123))
(10 rows)

i|v
-+-
(0 rows)

step s1_commit: COMMIT;

starting permutation: s0_update_l s1_tuplock_l_1 s0_commit s1_commit
step s0_update_l: UPDATE l SET i = i + 1;
step s1_tuplock_l_1: 
    EXPLAIN (VERBOSE, COSTS OFF)
    SELECT l.* FROM l, ft WHERE l.i = ft.i AND l.v = 'foo' FOR UPDATE OF l;
    SELECT l.* FROM l, ft WHERE l.i = ft.i AND l.v = 'foo' FOR UPDATE OF l;
 <waiting ...>
step s0_commit: COMMIT;
step s1_tuplock_l_1: <... completed>
QUERY PLAN                                                                   
-----------------------------------------------------------------------------
LockRows                                                                     
  Output: l.i, l.v, l.ctid, ft.*                                             
  ->  Nested Loop                                                            
        Output: l.i, l.v, l.ctid, ft.*                                       
        ->  Seq Scan on public.l                                             
              Output: l.i, l.v, l.ctid                                       
              Filter: (l.v = 'foo'::text)                                    
        ->  Foreign Scan on public.ft                                        
              Output: ft.*, ft.i                                             
              Remote SQL: SELECT i, v FROM public.t WHERE ((i = $1::integer))
(10 rows)

i|v
-+-
(0 rows)

step s1_commit: COMMIT;

starting permutation: s0_update_a s1_tuplock_a_0 s0_commit s1_commit
step s0_update_a: UPDATE a SET i = i + 1;
step s1_tuplock_a_0: 
    EXPLAIN (VERBOSE, COSTS OFF)
    SELECT a.i FROM a, fb, fc WHERE a.i = fb.i AND fb.i = fc.i FOR UPDATE OF a;
    SELECT a.i FROM a, fb, fc WHERE a.i = fb.i AND fb.i = fc.i FOR UPDATE OF a;
 <waiting ...>
step s0_commit: COMMIT;
step s1_tuplock_a_0: <... completed>
QUERY PLAN                                                                                                                                                                                                              
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
LockRows                                                                                                                                                                                                                
  Output: a.i, a.ctid, fb.*, fc.*                                                                                                                                                                                       
  ->  Nested Loop                                                                                                                                                                                                       
        Output: a.i, a.ctid, fb.*, fc.*                                                                                                                                                                                 
        Join Filter: (fb.i = a.i)                                                                                                                                                                                       
        ->  Foreign Scan                                                                                                                                                                                                
              Output: fb.*, fb.i, fc.*, fc.i                                                                                                                                                                            
              Relations: (public.fb) INNER JOIN (public.fc)                                                                                                                                                             
              Remote SQL: SELECT CASE WHEN (r2.*)::text IS NOT NULL THEN ROW(r2.i) END, r2.i, CASE WHEN (r3.*)::text IS NOT NULL THEN ROW(r3.i) END, r3.i FROM (public.b r2 INNER JOIN public.c r3 ON (((r2.i = r3.i))))
              ->  Nested Loop                                                                                                                                                                                           
                    Output: fb.*, fb.i, fc.*, fc.i                                                                                                                                                                      
                    Join Filter: (fb.i = fc.i)                                                                                                                                                                          
                    ->  Foreign Scan on public.fb                                                                                                                                                                       
                          Output: fb.*, fb.i                                                                                                                                                                            
                          Remote SQL: SELECT i FROM public.b ORDER BY i ASC NULLS LAST                                                                                                                                  
                    ->  Foreign Scan on public.fc                                                                                                                                                                       
                          Output: fc.*, fc.i                                                                                                                                                                            
                          Remote SQL: SELECT i FROM public.c                                                                                                                                                            
        ->  Seq Scan on public.a                                                                                                                                                                                        
              Output: a.i, a.ctid                                                                                                                                                                                       
(20 rows)

i
-
(0 rows)

step s1_commit: COMMIT;

starting permutation: s0_update_a s1_tuplock_a_1 s0_commit s1_commit
step s0_update_a: UPDATE a SET i = i + 1;
step s1_tuplock_a_1: 
    EXPLAIN (VERBOSE, COSTS OFF)
    SELECT a.i,
        (SELECT 1 FROM fb, fc WHERE a.i = fb.i AND fb.i = fc.i)
    FROM a FOR UPDATE;
    SELECT a.i,
        (SELECT 1 FROM fb, fc WHERE a.i = fb.i AND fb.i = fc.i)
    FROM a FOR UPDATE;
 <waiting ...>
step s0_commit: COMMIT;
step s1_tuplock_a_1: <... completed>
QUERY PLAN                                                                                                                              
----------------------------------------------------------------------------------------------------------------------------------------
LockRows                                                                                                                                
  Output: a.i, ((SubPlan expr_1)), a.ctid                                                                                               
  ->  Seq Scan on public.a                                                                                                              
        Output: a.i, (SubPlan expr_1), a.ctid                                                                                           
        SubPlan expr_1                                                                                                                  
          ->  Foreign Scan                                                                                                              
                Output: 1                                                                                                               
                Relations: (public.fb) INNER JOIN (public.fc)                                                                           
                Remote SQL: SELECT NULL FROM (public.b r1 INNER JOIN public.c r2 ON (((r2.i = $1::integer)) AND ((r1.i = $1::integer))))
(9 rows)

i|?column?
-+--------
2|        
(1 row)

step s1_commit: COMMIT;