Running 'tinytest.R' [289s]
Running the tests in 'tests/tinytest.R' failed.
Complete output:
  > 
  > if ( requireNamespace("tinytest", quietly=TRUE) ){
  +   # perform regular tests:
  +   tinytest::test_package("tinycodet", testdir = file.path("tinytest", "regular"))
  + 
  +   # perform special tests on fake packages:
  +   tinytest::test_package("tinycodet", testdir = file.path("tinytest", "special"))
  + }
  Run `?tinycodet::tinycodet` to open the introduction help page of 'tinycodet'.
  
  test-atomic_conversions.R.....    0 tests    
  test-atomic_conversions.R.....    0 tests    
  test-atomic_conversions.R.....    0 tests    
  test-atomic_conversions.R.....    0 tests    
  test-atomic_conversions.R.....    0 tests    
  test-atomic_conversions.R.....    0 tests    
  test-atomic_conversions.R.....    0 tests    
  test-atomic_conversions.R.....    0 tests    
  test-atomic_conversions.R.....    0 tests    
  test-atomic_conversions.R.....    1 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    1 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    1 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    2 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    2 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    2 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    3 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    3 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    3 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    4 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    4 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    4 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    4 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    4 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    4 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    4 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    4 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    4 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    5 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    5 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    5 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    5 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    6 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    6 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    6 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    6 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    7 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    7 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    7 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    7 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    8 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    8 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    8 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    8 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    8 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    8 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    8 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    8 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    8 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    9 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    9 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    9 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    9 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    9 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    9 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    9 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    9 tests [0;32mOK[0m 
  test-atomic_conversions.R.....    9 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   10 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   10 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   10 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   11 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   11 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   11 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   12 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   12 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   12 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   13 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   13 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   13 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   13 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   13 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   13 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   13 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   13 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   13 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   13 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   14 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   14 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   14 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   14 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   15 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   15 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   15 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   15 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   16 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   16 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   16 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   16 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   17 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   17 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   17 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   17 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   17 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   17 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   17 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   17 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   17 tests [0;32mOK[0m 
  test-atomic_conversions.R.....   18 tests [0;32mOK[0m [0;34m0.1s[0m
  
  test-constants.R..............    0 tests    
  test-constants.R..............    1 tests [0;32mOK[0m 
  test-constants.R..............    1 tests [0;32mOK[0m 
  test-constants.R..............    2 tests [0;32mOK[0m 
  test-constants.R..............    2 tests [0;32mOK[0m 
  test-constants.R..............    3 tests [0;32mOK[0m 
  test-constants.R..............    3 tests [0;32mOK[0m 
  test-constants.R..............    4 tests [0;32mOK[0m 
  test-constants.R..............    4 tests [0;32mOK[0m 
  test-constants.R..............    5 tests [0;32mOK[0m 
  test-constants.R..............    5 tests [0;32mOK[0m 
  test-constants.R..............    6 tests [0;32mOK[0m 
  test-constants.R..............    6 tests [0;32mOK[0m 
  test-constants.R..............    7 tests [0;32mOK[0m 
  test-constants.R..............    7 tests [0;32mOK[0m 
  test-constants.R..............    8 tests [0;32mOK[0m 
  test-constants.R..............    8 tests [0;32mOK[0m 
  test-constants.R..............    9 tests [0;32mOK[0m 
  test-constants.R..............    9 tests [0;32mOK[0m 
  test-constants.R..............   10 tests [0;32mOK[0m 
  test-constants.R..............   10 tests [0;32mOK[0m 
  test-constants.R..............   11 tests [0;32mOK[0m 
  test-constants.R..............   11 tests [0;32mOK[0m 
  test-constants.R..............   12 tests [0;32mOK[0m 
  test-constants.R..............   12 tests [0;32mOK[0m 
  test-constants.R..............   13 tests [0;32mOK[0m 
  test-constants.R..............   13 tests [0;32mOK[0m 
  test-constants.R..............   14 tests [0;32mOK[0m 
  test-constants.R..............   14 tests [0;32mOK[0m 
  test-constants.R..............   15 tests [0;32mOK[0m 
  test-constants.R..............   15 tests [0;32mOK[0m 
  test-constants.R..............   16 tests [0;32mOK[0m 
  test-constants.R..............   16 tests [0;32mOK[0m 
  test-constants.R..............   17 tests [0;32mOK[0m 
  test-constants.R..............   17 tests [0;32mOK[0m 
  test-constants.R..............   18 tests [0;32mOK[0m 
  test-constants.R..............   18 tests [0;32mOK[0m 
  test-constants.R..............   18 tests [0;32mOK[0m 
  test-constants.R..............   19 tests [0;32mOK[0m 
  test-constants.R..............   20 tests [0;32mOK[0m 
  test-constants.R..............   21 tests [0;32mOK[0m 
  test-constants.R..............   22 tests [0;32mOK[0m [0;36m10ms[0m
  
  test-decimal-between.R........    0 tests    
  test-decimal-between.R........    0 tests    
  test-decimal-between.R........    0 tests    
  test-decimal-between.R........    0 tests    
  test-decimal-between.R........    0 tests    
  test-decimal-between.R........    0 tests    
  test-decimal-between.R........    0 tests    
  test-decimal-between.R........    0 tests    
  test-decimal-between.R........    0 tests    
  test-decimal-between.R........    1 tests [0;32mOK[0m 
  test-decimal-between.R........    2 tests [0;32mOK[0m 
  test-decimal-between.R........    3 tests [0;32mOK[0m 
  test-decimal-between.R........    4 tests [0;32mOK[0m 
  test-decimal-between.R........    5 tests [0;32mOK[0m 
  test-decimal-between.R........    6 tests [0;32mOK[0m 
  test-decimal-between.R........    7 tests [0;32mOK[0m 
  test-decimal-between.R........    8 tests [0;32mOK[0m 
  test-decimal-between.R........    9 tests [0;32mOK[0m 
  test-decimal-between.R........   10 tests [0;32mOK[0m 
  test-decimal-between.R........   11 tests [0;32mOK[0m 
  test-decimal-between.R........   12 tests [0;32mOK[0m 
  test-decimal-between.R........   13 tests [0;32mOK[0m 
  test-decimal-between.R........   13 tests [0;32mOK[0m 
  test-decimal-between.R........   13 tests [0;32mOK[0m 
  test-decimal-between.R........   14 tests [0;32mOK[0m 
  test-decimal-between.R........   14 tests [0;32mOK[0m 
  test-decimal-between.R........   14 tests [0;32mOK[0m 
  test-decimal-between.R........   14 tests [0;32mOK[0m 
  test-decimal-between.R........   14 tests [0;32mOK[0m 
  test-decimal-between.R........   14 tests [0;32mOK[0m 
  test-decimal-between.R........   15 tests [0;32mOK[0m 
  test-decimal-between.R........   16 tests [0;32mOK[0m 
  test-decimal-between.R........   17 tests [0;32mOK[0m 
  test-decimal-between.R........   18 tests [0;32mOK[0m 
  test-decimal-between.R........   19 tests [0;32mOK[0m [0;36m18ms[0m
  
  test-decimal-eq.R.............    0 tests    
  test-decimal-eq.R.............    0 tests    
  test-decimal-eq.R.............    0 tests    
  test-decimal-eq.R.............    0 tests    
  test-decimal-eq.R.............    0 tests    
  test-decimal-eq.R.............    0 tests    
  test-decimal-eq.R.............    0 tests    
  test-decimal-eq.R.............    1 tests [0;32mOK[0m 
  test-decimal-eq.R.............    2 tests [0;32mOK[0m 
  test-decimal-eq.R.............    3 tests [0;32mOK[0m 
  test-decimal-eq.R.............    4 tests [0;32mOK[0m 
  test-decimal-eq.R.............    5 tests [0;32mOK[0m 
  test-decimal-eq.R.............    6 tests [0;32mOK[0m 
  test-decimal-eq.R.............    7 tests [0;32mOK[0m 
  test-decimal-eq.R.............    8 tests [0;32mOK[0m 
  test-decimal-eq.R.............    9 tests [0;32mOK[0m 
  test-decimal-eq.R.............    9 tests [0;32mOK[0m 
  test-decimal-eq.R.............   10 tests [0;32mOK[0m 
  test-decimal-eq.R.............   11 tests [0;32mOK[0m 
  test-decimal-eq.R.............   12 tests [0;32mOK[0m 
  test-decimal-eq.R.............   13 tests [0;32mOK[0m 
  test-decimal-eq.R.............   14 tests [0;32mOK[0m 
  test-decimal-eq.R.............   15 tests [0;32mOK[0m 
  test-decimal-eq.R.............   15 tests [0;32mOK[0m 
  test-decimal-eq.R.............   15 tests [0;32mOK[0m 
  test-decimal-eq.R.............   15 tests [0;32mOK[0m 
  test-decimal-eq.R.............   16 tests [0;32mOK[0m 
  test-decimal-eq.R.............   17 tests [0;32mOK[0m 
  test-decimal-eq.R.............   18 tests [0;32mOK[0m 
  test-decimal-eq.R.............   19 tests [0;32mOK[0m 
  test-decimal-eq.R.............   20 tests [0;32mOK[0m 
  test-decimal-eq.R.............   21 tests [0;32mOK[0m 
  test-decimal-eq.R.............   22 tests [0;32mOK[0m 
  test-decimal-eq.R.............   23 tests [0;32mOK[0m 
  test-decimal-eq.R.............   24 tests [0;32mOK[0m 
  test-decimal-eq.R.............   25 tests [0;32mOK[0m 
  test-decimal-eq.R.............   26 tests [0;32mOK[0m 
  test-decimal-eq.R.............   27 tests [0;32mOK[0m 
  test-decimal-eq.R.............   28 tests [0;32mOK[0m 
  test-decimal-eq.R.............   29 tests [0;32mOK[0m 
  test-decimal-eq.R.............   30 tests [0;32mOK[0m 
  test-decimal-eq.R.............   31 tests [0;32mOK[0m 
  test-decimal-eq.R.............   32 tests [0;32mOK[0m 
  test-decimal-eq.R.............   33 tests [0;32mOK[0m 
  test-decimal-eq.R.............   34 tests [0;32mOK[0m 
  test-decimal-eq.R.............   35 tests [0;32mOK[0m 
  test-decimal-eq.R.............   36 tests [0;32mOK[0m 
  test-decimal-eq.R.............   37 tests [0;32mOK[0m 
  test-decimal-eq.R.............   38 tests [0;32mOK[0m 
  test-decimal-eq.R.............   39 tests [0;32mOK[0m 
  test-decimal-eq.R.............   40 tests [0;32mOK[0m 
  test-decimal-eq.R.............   41 tests [0;32mOK[0m [0;36m16ms[0m
  
  test-decimal-is_wholenumber.R.    0 tests    
  test-decimal-is_wholenumber.R.    0 tests    
  test-decimal-is_wholenumber.R.    0 tests    
  test-decimal-is_wholenumber.R.    1 tests [0;32mOK[0m 
  test-decimal-is_wholenumber.R.    2 tests [0;32mOK[0m 
  test-decimal-is_wholenumber.R.    3 tests [0;32mOK[0m 
  test-decimal-is_wholenumber.R.    4 tests [0;32mOK[0m 
  test-decimal-is_wholenumber.R.    5 tests [0;32mOK[0m 
  test-decimal-is_wholenumber.R.    6 tests [0;32mOK[0m 
  test-decimal-is_wholenumber.R.    7 tests [0;32mOK[0m 
  test-decimal-is_wholenumber.R.    8 tests [0;32mOK[0m 
  test-decimal-is_wholenumber.R.    9 tests [0;32mOK[0m 
  test-decimal-is_wholenumber.R.   10 tests [0;32mOK[0m 
  test-decimal-is_wholenumber.R.   10 tests [0;32mOK[0m 
  test-decimal-is_wholenumber.R.   11 tests [0;32mOK[0m 
  test-decimal-is_wholenumber.R.   12 tests [0;32mOK[0m 
  test-decimal-is_wholenumber.R.   13 tests [0;32mOK[0m 
  test-decimal-is_wholenumber.R.   14 tests [0;32mOK[0m 
  test-decimal-is_wholenumber.R.   15 tests [0;32mOK[0m 
  test-decimal-is_wholenumber.R.   16 tests [0;32mOK[0m 
  test-decimal-is_wholenumber.R.   17 tests [0;32mOK[0m 
  test-decimal-is_wholenumber.R.   18 tests [0;32mOK[0m 
  test-decimal-is_wholenumber.R.   19 tests [0;32mOK[0m [0;36m9ms[0m
  
  test-dry.R....................    0 tests    
  test-dry.R....................    0 tests    
  test-dry.R....................    0 tests    
  test-dry.R....................    0 tests    
  test-dry.R....................    0 tests    
  test-dry.R....................    0 tests    
  test-dry.R....................    0 tests    
  test-dry.R....................    0 tests    
  test-dry.R....................    0 tests    
  test-dry.R....................    0 tests    
  test-dry.R....................    1 tests [0;32mOK[0m 
  test-dry.R....................    2 tests [0;32mOK[0m 
  test-dry.R....................    3 tests [0;32mOK[0m 
  test-dry.R....................    4 tests [0;32mOK[0m 
  test-dry.R....................    5 tests [0;32mOK[0m 
  test-dry.R....................    5 tests [0;32mOK[0m 
  test-dry.R....................    6 tests [0;32mOK[0m 
  test-dry.R....................    6 tests [0;32mOK[0m 
  test-dry.R....................    6 tests [0;32mOK[0m 
  test-dry.R....................    6 tests [0;32mOK[0m 
  test-dry.R....................    6 tests [0;32mOK[0m 
  test-dry.R....................    6 tests [0;32mOK[0m 
  test-dry.R....................    6 tests [0;32mOK[0m 
  test-dry.R....................    6 tests [0;32mOK[0m 
  test-dry.R....................    6 tests [0;32mOK[0m 
  test-dry.R....................    6 tests [0;32mOK[0m 
  test-dry.R....................    7 tests [0;32mOK[0m 
  test-dry.R....................    8 tests [0;32mOK[0m 
  test-dry.R....................    9 tests [0;32mOK[0m 
  test-dry.R....................   10 tests [0;32mOK[0m 
  test-dry.R....................   11 tests [0;32mOK[0m 
  test-dry.R....................   12 tests [0;32mOK[0m 
  test-dry.R....................   13 tests [0;32mOK[0m 
  test-dry.R....................   14 tests [0;32mOK[0m 
  test-dry.R....................   15 tests [0;32mOK[0m 
  test-dry.R....................   15 tests [0;32mOK[0m 
  test-dry.R....................   16 tests [0;32mOK[0m 
  test-dry.R....................   17 tests [0;32mOK[0m 
  test-dry.R....................   18 tests [0;32mOK[0m 
  test-dry.R....................   19 tests [0;32mOK[0m 
  test-dry.R....................   19 tests [0;32mOK[0m 
  test-dry.R....................   19 tests [0;32mOK[0m 
  test-dry.R....................   20 tests [0;32mOK[0m 
  test-dry.R....................   20 tests [0;32mOK[0m 
  test-dry.R....................   20 tests [0;32mOK[0m 
  test-dry.R....................   20 tests [0;32mOK[0m 
  test-dry.R....................   20 tests [0;32mOK[0m 
  test-dry.R....................   21 tests [0;32mOK[0m 
  test-dry.R....................   21 tests [0;32mOK[0m 
  test-dry.R....................   21 tests [0;32mOK[0m 
  test-dry.R....................   21 tests [0;32mOK[0m 
  test-dry.R....................   21 tests [0;32mOK[0m 
  test-dry.R....................   22 tests [0;32mOK[0m [0;36m20ms[0m
  
  test-form.R...................    0 tests    
  test-form.R...................    0 tests    
  test-form.R...................    1 tests [0;32mOK[0m 
  test-form.R...................    2 tests [0;32mOK[0m 
  test-form.R...................    3 tests [0;32mOK[0m 
  test-form.R...................    4 tests [0;32mOK[0m 
  test-form.R...................    4 tests [0;32mOK[0m 
  test-form.R...................    5 tests [0;32mOK[0m 
  test-form.R...................    5 tests [0;32mOK[0m 
  test-form.R...................    5 tests [0;32mOK[0m 
  test-form.R...................    6 tests [0;32mOK[0m 
  test-form.R...................    7 tests [0;32mOK[0m 
  test-form.R...................    8 tests [0;32mOK[0m 
  test-form.R...................    8 tests [0;32mOK[0m 
  test-form.R...................    9 tests [0;32mOK[0m 
  test-form.R...................    9 tests [0;32mOK[0m 
  test-form.R...................   10 tests [0;32mOK[0m Loading required namespace: mgcv
  
  test-form.R...................   11 tests [0;32mOK[0m 
  test-form.R...................   12 tests [0;32mOK[0m Loading required namespace: ggplot2
  
  test-form.R...................   13 tests [0;32mOK[0m 
  test-form.R...................   13 tests [0;32mOK[0m 
  test-form.R...................   13 tests [0;32mOK[0m 
  test-form.R...................   13 tests [0;32mOK[0m 
  test-form.R...................   14 tests [0;32mOK[0m 
  test-form.R...................   15 tests [0;32mOK[0m 
  test-form.R...................   16 tests [0;32mOK[0m 
  test-form.R...................   16 tests [0;32mOK[0m 
  test-form.R...................   16 tests [0;32mOK[0m 
  test-form.R...................   17 tests [0;32mOK[0m 
  test-form.R...................   17 tests [0;32mOK[0m 
  test-form.R...................   17 tests [0;32mOK[0m 
  test-form.R...................   18 tests [0;32mOK[0m 
  test-form.R...................   19 tests [0;32mOK[0m 
  test-form.R...................   20 tests [0;32mOK[0m 
  test-form.R...................   21 tests [0;32mOK[0m 
  test-form.R...................   21 tests [0;32mOK[0m 
  test-form.R...................   21 tests [0;32mOK[0m 
  test-form.R...................   22 tests [0;32mOK[0m 
  test-form.R...................   23 tests [0;32mOK[0m 
  test-form.R...................   24 tests [0;32mOK[0m 
  test-form.R...................   24 tests [0;32mOK[0m 
  test-form.R...................   25 tests [0;32mOK[0m 
  test-form.R...................   25 tests [0;32mOK[0m 
  test-form.R...................   26 tests [0;32mOK[0m 
  test-form.R...................   27 tests [0;32mOK[0m 
  test-form.R...................   28 tests [0;32mOK[0m 
  test-form.R...................   29 tests [0;32mOK[0m 
  test-form.R...................   29 tests [0;32mOK[0m 
  test-form.R...................   29 tests [0;32mOK[0m 
  test-form.R...................   29 tests [0;32mOK[0m 
  test-form.R...................   30 tests [0;32mOK[0m 
  test-form.R...................   31 tests [0;32mOK[0m 
  test-form.R...................   32 tests [0;32mOK[0m 
  test-form.R...................   32 tests [0;32mOK[0m 
  test-form.R...................   32 tests [0;32mOK[0m 
  test-form.R...................   33 tests [0;32mOK[0m 
  test-form.R...................   33 tests [0;32mOK[0m 
  test-form.R...................   33 tests [0;32mOK[0m 
  test-form.R...................   34 tests [0;32mOK[0m 
  test-form.R...................   35 tests [0;32mOK[0m 
  test-form.R...................   36 tests [0;32mOK[0m 
  test-form.R...................   37 tests [0;32mOK[0m 
  test-form.R...................   37 tests [0;32mOK[0m 
  test-form.R...................   37 tests [0;32mOK[0m 
  test-form.R...................   38 tests [0;32mOK[0m 
  test-form.R...................   38 tests [0;32mOK[0m 
  test-form.R...................   38 tests [0;32mOK[0m 
  test-form.R...................   39 tests [0;32mOK[0m 
  test-form.R...................   39 tests [0;32mOK[0m 
  test-form.R...................   40 tests [0;32mOK[0m 
  test-form.R...................   40 tests [0;32mOK[0m 
  test-form.R...................   41 tests [0;32mOK[0m 
  test-form.R...................   41 tests [0;32mOK[0m 
  test-form.R...................   42 tests [0;32mOK[0m 
  test-form.R...................   43 tests [0;32mOK[0m 
  test-form.R...................   44 tests [0;32mOK[0m [0;34m23.5s[0m
  
  test-import_LL.R..............    0 tests    
  test-import_LL.R..............    1 tests [0;32mOK[0m 
  test-import_LL.R..............    1 tests [0;32mOK[0m 
  test-import_LL.R..............    1 tests [0;32mOK[0m 
  test-import_LL.R..............    2 tests [0;32mOK[0m 
  test-import_LL.R..............    2 tests [0;32mOK[0m 
  test-import_LL.R..............    3 tests [0;32mOK[0m 
  test-import_LL.R..............    3 tests [0;32mOK[0m 
  test-import_LL.R..............    4 tests [0;32mOK[0m 
  test-import_LL.R..............    4 tests [0;32mOK[0m 
  test-import_LL.R..............    5 tests [0;32mOK[0m 
  test-import_LL.R..............    5 tests [0;32mOK[0m checking for infix operators exposed to the current environment by `import_inops()` ...
  Removing the following infix operators:
  %stri+%
  Done
  
  test-import_LL.R..............    6 tests [0;32mOK[0m 
  test-import_LL.R..............    6 tests [0;32mOK[0m 
  test-import_LL.R..............    7 tests [0;32mOK[0m 
  test-import_LL.R..............    8 tests [0;32mOK[0m 
  test-import_LL.R..............    9 tests [0;32mOK[0m 
  test-import_LL.R..............   10 tests [0;32mOK[0m 
  test-import_LL.R..............   11 tests [0;32mOK[0m 
  test-import_LL.R..............   12 tests [0;32mOK[0m 
  test-import_LL.R..............   13 tests [0;32mOK[0m 
  test-import_LL.R..............   14 tests [0;32mOK[0m 
  test-import_LL.R..............   15 tests [0;32mOK[0m 
  test-import_LL.R..............   16 tests [0;32mOK[0m 
  test-import_LL.R..............   17 tests [0;32mOK[0m 
  test-import_LL.R..............   18 tests [0;32mOK[0m 
  test-import_LL.R..............   19 tests [0;32mOK[0m 
  test-import_LL.R..............   20 tests [0;32mOK[0m [0;34m0.2s[0m
  
  test-import_as.R..............    0 tests    
  test-import_as.R..............    0 tests    Importing packages and registering methods...
  Done
  You can now access the functions using `stri.$`
  For conflicts report, packages order, and other attributes, run `attr.import(stri.)` 
  
  
  test-import_as.R..............    1 tests [0;32mOK[0m 
  test-import_as.R..............    1 tests [0;32mOK[0m Importing packages and registering methods...
  Done
  You can now access the functions using `stri.$`
  For conflicts report, packages order, and other attributes, run `attr.import(stri.)` 
  
  
  test-import_as.R..............    2 tests [0;32mOK[0m 
  test-import_as.R..............    3 tests [0;32mOK[0m 
  test-import_as.R..............    4 tests [0;32mOK[0m 
  test-import_as.R..............    5 tests [0;32mOK[0m 
  test-import_as.R..............    6 tests [0;32mOK[0m 
  test-import_as.R..............    7 tests [0;32mOK[0m 
  test-import_as.R..............    8 tests [0;32mOK[0m 
  test-import_as.R..............    9 tests [0;32mOK[0m 
  test-import_as.R..............   10 tests [0;32mOK[0m 
  test-import_as.R..............   11 tests [0;32mOK[0m 
  test-import_as.R..............   12 tests [0;32mOK[0m 
  test-import_as.R..............   13 tests [0;32mOK[0m 
  test-import_as.R..............   14 tests [0;32mOK[0m 
  test-import_as.R..............   15 tests [0;32mOK[0m 
  test-import_as.R..............   16 tests [0;32mOK[0m 
  test-import_as.R..............   17 tests [0;32mOK[0m 
  test-import_as.R..............   18 tests [0;32mOK[0m 
  test-import_as.R..............   19 tests [0;32mOK[0m 
  test-import_as.R..............   20 tests [0;32mOK[0m 
  test-import_as.R..............   21 tests [0;32mOK[0m 
  test-import_as.R..............   22 tests [0;32mOK[0m 
  test-import_as.R..............   23 tests [0;32mOK[0m 
  test-import_as.R..............   23 tests [0;32mOK[0m Importing packages and registering methods...
  Done
  You can now access the functions using `stri.$`
  For conflicts report, packages order, and other attributes, run `attr.import(stri.)` 
  
  
  test-import_as.R..............   24 tests [0;32mOK[0m [0;36m70ms[0m
  
  test-import_data.R............    0 tests    
  test-import_data.R............    1 tests [0;32mOK[0m 
  test-import_data.R............    2 tests [0;32mOK[0m 
  test-import_data.R............    3 tests [0;32mOK[0m 
  test-import_data.R............    4 tests [0;32mOK[0m [0;36m7ms[0m
  
  test-import_general.R.........    0 tests    
  test-import_general.R.........    0 tests    
  test-import_general.R.........    0 tests    
  test-import_general.R.........    1 tests [0;32mOK[0m 
  test-import_general.R.........    2 tests [0;32mOK[0m 
  test-import_general.R.........    3 tests [0;32mOK[0m 
  test-import_general.R.........    4 tests [0;32mOK[0m 
  test-import_general.R.........    5 tests [0;32mOK[0m 
  test-import_general.R.........    6 tests [0;32mOK[0m 
  test-import_general.R.........    6 tests [0;32mOK[0m 
  test-import_general.R.........    6 tests [0;32mOK[0m ----- PASSED      : test-import_general.R<42--64>
   call| expect_error(import_as(~stri., i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<42--64>
   call| expect_error(import_inops(i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<42--64>
   call| expect_error(import_LL(i, "foo"), pattern = pattern) 
  ----- PASSED      : test-import_general.R<42--64>
   call| expect_error(pversion_check4mismatch(i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<42--64>
   call| expect_error(pversion_report(i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<42--64>
   call| expect_error(import_as(~stri., i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<42--64>
   call| expect_error(import_inops(i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<42--64>
   call| expect_error(import_LL(i, "foo"), pattern = pattern) 
  ----- PASSED      : test-import_general.R<42--64>
   call| expect_error(pversion_check4mismatch(i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<42--64>
   call| expect_error(pversion_report(i), pattern = pattern) 
  
  test-import_general.R.........   16 tests [0;32mOK[0m 
  test-import_general.R.........   17 tests [0;32mOK[0m 
  test-import_general.R.........   17 tests [0;32mOK[0m 
  test-import_general.R.........   17 tests [0;32mOK[0m 
  test-import_general.R.........   17 tests [0;32mOK[0m ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_as(~stri., i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_inops(i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_LL(i, "foo"), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_int(form), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_as(~stri., i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_inops(i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_LL(i, "foo"), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_int(form), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_as(~stri., i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_inops(i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_LL(i, "foo"), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_int(form), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_as(~stri., i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_inops(i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_LL(i, "foo"), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_int(form), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_as(~stri., i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_inops(i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_LL(i, "foo"), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_int(form), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_as(~stri., i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_inops(i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_LL(i, "foo"), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_int(form), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_as(~stri., i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_inops(i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_LL(i, "foo"), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_int(form), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_as(~stri., i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_inops(i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_LL(i, "foo"), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_int(form), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_as(~stri., i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_inops(i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_LL(i, "foo"), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_int(form), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_as(~stri., i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_inops(i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_LL(i, "foo"), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_int(form), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_as(~stri., i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_inops(i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_LL(i, "foo"), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_int(form), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_as(~stri., i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_inops(i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_LL(i, "foo"), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_int(form), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_as(~stri., i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_inops(i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_LL(i, "foo"), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_int(form), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_as(~stri., i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_inops(i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_LL(i, "foo"), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_int(form), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_as(~stri., i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_inops(i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_LL(i, "foo"), pattern = pattern) 
  ----- PASSED      : test-import_general.R<79--98>
   call| expect_error(import_int(form), pattern = pattern) 
  
  test-import_general.R.........   77 tests [0;32mOK[0m 
  test-import_general.R.........   77 tests [0;32mOK[0m 
  test-import_general.R.........   77 tests [0;32mOK[0m 
  test-import_general.R.........   77 tests [0;32mOK[0m ----- PASSED      : test-import_general.R<107--134>
   call| expect_error(import_as(~stri., i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<107--134>
   call| expect_error(import_inops(i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<107--134>
   call| expect_error(import_LL(i, "foo"), pattern = pattern) 
  ----- PASSED      : test-import_general.R<107--134>
   call| expect_error(import_int(form), pattern = pattern) 
  ----- PASSED      : test-import_general.R<107--134>
   call| expect_error(pversion_check4mismatch(i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<107--134>
   call| expect_error(pversion_report(i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<107--134>
   call| expect_error(import_as(~stri., i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<107--134>
   call| expect_error(import_inops(i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<107--134>
   call| expect_error(import_LL(i, "foo"), pattern = pattern) 
  ----- PASSED      : test-import_general.R<107--134>
   call| expect_error(import_int(form), pattern = pattern) 
  ----- PASSED      : test-import_general.R<107--134>
   call| expect_error(pversion_check4mismatch(i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<107--134>
   call| expect_error(pversion_report(i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<107--134>
   call| expect_error(import_as(~stri., i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<107--134>
   call| expect_error(import_inops(i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<107--134>
   call| expect_error(import_LL(i, "foo"), pattern = pattern) 
  ----- PASSED      : test-import_general.R<107--134>
   call| expect_error(import_int(form), pattern = pattern) 
  ----- PASSED      : test-import_general.R<107--134>
   call| expect_error(pversion_check4mismatch(i), pattern = pattern) 
  ----- PASSED      : test-import_general.R<107--134>
   call| expect_error(pversion_report(i), pattern = pattern) 
  
  test-import_general.R.........   95 tests [0;32mOK[0m 
  test-import_general.R.........   96 tests [0;32mOK[0m 
  test-import_general.R.........   97 tests [0;32mOK[0m 
  test-import_general.R.........   98 tests [0;32mOK[0m 
  test-import_general.R.........   99 tests [0;32mOK[0m 
  test-import_general.R.........  100 tests [0;32mOK[0m 
  test-import_general.R.........  101 tests [0;32mOK[0m 
  test-import_general.R.........  102 tests [0;32mOK[0m [0;34m0.4s[0m
  
  test-import_inops-alias.R.....    0 tests    
  test-import_inops-alias.R.....    0 tests    Importing packages and registering methods...
  Done
  You can now access the functions using `stri.$`
  For conflicts report, packages order, and other attributes, run `attr.import(stri.)` 
  
  Checking for conflicting infix operators in the current environment...
  Placing infix operators in current environment...
  Done
  
  test-import_inops-alias.R.....    1 tests [0;32mOK[0m 
  test-import_inops-alias.R.....    1 tests [0;32mOK[0m 
  test-import_inops-alias.R.....    1 tests [0;32mOK[0m Importing packages and registering methods...
  Done
  You can now access the functions using `stri.$`
  For conflicts report, packages order, and other attributes, run `attr.import(stri.)` 
  
  Checking for conflicting infix operators in the current environment...
  Placing infix operators in current environment...
  Done
  
  test-import_inops-alias.R.....    2 tests [0;32mOK[0m 
  test-import_inops-alias.R.....    2 tests [0;32mOK[0m 
  test-import_inops-alias.R.....    2 tests [0;32mOK[0m 
  test-import_inops-alias.R.....    2 tests [0;32mOK[0m Importing packages and registering methods...
  Done
  You can now access the functions using `stri.$`
  For conflicts report, packages order, and other attributes, run `attr.import(stri.)` 
  
  Checking for conflicting infix operators in the current environment...
  Placing infix operators in current environment...
  Done
  
  test-import_inops-alias.R.....    3 tests [0;32mOK[0m 
  test-import_inops-alias.R.....    3 tests [0;32mOK[0m Importing packages and registering methods...
  Done
  You can now access the functions using `stri.$`
  For conflicts report, packages order, and other attributes, run `attr.import(stri.)` 
  
  Checking for conflicting infix operators in the current environment...
  Placing infix operators in current environment...
  Done
  unexposing infix operators...
  Done
  
  test-import_inops-alias.R.....    4 tests [0;32mOK[0m 
  test-import_inops-alias.R.....    4 tests [0;32mOK[0m Importing packages and registering methods...
  Done
  You can now access the functions using `stri.$`
  For conflicts report, packages order, and other attributes, run `attr.import(stri.)` 
  
  Checking for conflicting infix operators in the current environment...
  Placing infix operators in current environment...
  Done
  
  test-import_inops-alias.R.....    5 tests [0;32mOK[0m 
  test-import_inops-alias.R.....    5 tests [0;32mOK[0m Importing packages and registering methods...
  Done
  You can now access the functions using `stri.$`
  For conflicts report, packages order, and other attributes, run `attr.import(stri.)` 
  
  
  test-import_inops-alias.R.....    6 tests [0;32mOK[0m 
  test-import_inops-alias.R.....    6 tests [0;32mOK[0m Importing packages and registering methods...
  Done
  You can now access the functions using `stri.$`
  For conflicts report, packages order, and other attributes, run `attr.import(stri.)` 
  
  
  test-import_inops-alias.R.....    7 tests [0;32mOK[0m 
  test-import_inops-alias.R.....    7 tests [0;32mOK[0m Importing packages and registering methods...
  Done
  You can now access the functions using `stri.$`
  For conflicts report, packages order, and other attributes, run `attr.import(stri.)` 
  
  
  test-import_inops-alias.R.....    8 tests [0;32mOK[0m 
  test-import_inops-alias.R.....    8 tests [0;32mOK[0m 
  test-import_inops-alias.R.....    9 tests [0;32mOK[0m 
  test-import_inops-alias.R.....    9 tests [0;32mOK[0m 
  test-import_inops-alias.R.....   10 tests [0;32mOK[0m 
  test-import_inops-alias.R.....   10 tests [0;32mOK[0m 
  test-import_inops-alias.R.....   11 tests [0;32mOK[0m [0;34m0.2s[0m
  
  test-import_inops-pkgs.R......    0 tests    
  test-import_inops-pkgs.R......    0 tests    Checking for conflicting infix operators in the current environment...
  Placing infix operators in current environment...
  Done
  
  test-import_inops-pkgs.R......    1 tests [0;32mOK[0m 
  test-import_inops-pkgs.R......    1 tests [0;32mOK[0m 
  test-import_inops-pkgs.R......    1 tests [0;32mOK[0m Checking for conflicting infix operators in the current environment...
  Placing infix operators in current environment...
  Done
  
  test-import_inops-pkgs.R......    2 tests [0;32mOK[0m 
  test-import_inops-pkgs.R......    2 tests [0;32mOK[0m 
  test-import_inops-pkgs.R......    2 tests [0;32mOK[0m 
  test-import_inops-pkgs.R......    2 tests [0;32mOK[0m Checking for conflicting infix operators in the current environment...
  Placing infix operators in current environment...
  Done
  
  test-import_inops-pkgs.R......    3 tests [0;32mOK[0m 
  test-import_inops-pkgs.R......    3 tests [0;32mOK[0m Checking for conflicting infix operators in the current environment...
  Placing infix operators in current environment...
  Done
  checking for infix operators exposed to the current environment by `import_inops()` ...
  Removing the following infix operators:
  %s!=%, %s!==%, %s$%, %s*%, %s+%, %s<%, %s<=%, %s==%, %s===%, %s>%, %s>=%, %stri!=%, %stri!==%, %stri$%, %stri*%, %stri+%, %stri<%, %stri<=%, %stri==%, %stri===%, %stri>%, %stri>=%
  Done
  
  test-import_inops-pkgs.R......    4 tests [0;32mOK[0m 
  test-import_inops-pkgs.R......    4 tests [0;32mOK[0m Checking for conflicting infix operators in the current environment...
  Placing infix operators in current environment...
  Done
  
  test-import_inops-pkgs.R......    5 tests [0;32mOK[0m 
  test-import_inops-pkgs.R......    5 tests [0;32mOK[0m 
  test-import_inops-pkgs.R......    6 tests [0;32mOK[0m 
  test-import_inops-pkgs.R......    7 tests [0;32mOK[0m 
  test-import_inops-pkgs.R......    8 tests [0;32mOK[0m 
  test-import_inops-pkgs.R......    9 tests [0;32mOK[0m 
  test-import_inops-pkgs.R......   10 tests [0;32mOK[0m 
  test-import_inops-pkgs.R......   11 tests [0;32mOK[0m 
  test-import_inops-pkgs.R......   12 tests [0;32mOK[0m 
  test-import_inops-pkgs.R......   13 tests [0;32mOK[0m 
  test-import_inops-pkgs.R......   14 tests [0;32mOK[0m 
  test-import_inops-pkgs.R......   15 tests [0;32mOK[0m 
  test-import_inops-pkgs.R......   15 tests [0;32mOK[0m 
  test-import_inops-pkgs.R......   16 tests [0;32mOK[0m [0;34m0.2s[0m
  
  test-import_inops.control.R...    0 tests    Importing packages and registering methods...
  Done
  You can now access the functions using `stri.$`
  For conflicts report, packages order, and other attributes, run `attr.import(stri.)` 
  
  
  test-import_inops.control.R...    1 tests [0;32mOK[0m 
  test-import_inops.control.R...    1 tests [0;32mOK[0m Importing packages and registering methods...
  Done
  You can now access the functions using `stri.$`
  For conflicts report, packages order, and other attributes, run `attr.import(stri.)` 
  
  
  test-import_inops.control.R...    2 tests [0;32mOK[0m 
  test-import_inops.control.R...    2 tests [0;32mOK[0m Importing packages and registering methods...
  Done
  You can now access the functions using `stri.$`
  For conflicts report, packages order, and other attributes, run `attr.import(stri.)` 
  
  
  test-import_inops.control.R...    3 tests [0;32mOK[0m 
  test-import_inops.control.R...    3 tests [0;32mOK[0m Importing packages and registering methods...
  Done
  You can now access the functions using `stri.$`
  For conflicts report, packages order, and other attributes, run `attr.import(stri.)` 
  
  
  test-import_inops.control.R...    4 tests [0;32mOK[0m 
  test-import_inops.control.R...    4 tests [0;32mOK[0m Importing packages and registering methods...
  Done
  You can now access the functions using `stri.$`
  For conflicts report, packages order, and other attributes, run `attr.import(stri.)` 
  
  
  test-import_inops.control.R...    5 tests [0;32mOK[0m 
  test-import_inops.control.R...    5 tests [0;32mOK[0m Importing packages and registering methods...
  Done
  You can now access the functions using `stri.$`
  For conflicts report, packages order, and other attributes, run `attr.import(stri.)` 
  
  
  test-import_inops.control.R...    6 tests [0;32mOK[0m 
  test-import_inops.control.R...    6 tests [0;32mOK[0m Importing packages and registering methods...
  Done
  You can now access the functions using `stri.$`
  For conflicts report, packages order, and other attributes, run `attr.import(stri.)` 
  
  
  test-import_inops.control.R...    7 tests [0;32mOK[0m 
  test-import_inops.control.R...    7 tests [0;32mOK[0m Importing packages and registering methods...
  Done
  You can now access the functions using `stri.$`
  For conflicts report, packages order, and other attributes, run `attr.import(stri.)` 
  
  
  test-import_inops.control.R...    8 tests [0;32mOK[0m 
  test-import_inops.control.R...    8 tests [0;32mOK[0m Importing packages and registering methods...
  Done
  You can now access the functions using `stri.$`
  For conflicts report, packages order, and other attributes, run `attr.import(stri.)` 
  
  
  test-import_inops.control.R...    9 tests [0;32mOK[0m 
  test-import_inops.control.R...    9 tests [0;32mOK[0m Importing packages and registering methods...
  Done
  You can now access the functions using `stri.$`
  For conflicts report, packages order, and other attributes, run `attr.import(stri.)` 
  
  
  test-import_inops.control.R...   10 tests [0;32mOK[0m 
  test-import_inops.control.R...   10 tests [0;32mOK[0m Importing packages and registering methods...
  Done
  You can now access the functions using `stri.$`
  For conflicts report, packages order, and other attributes, run `attr.import(stri.)` 
  
  
  test-import_inops.control.R...   11 tests [0;32mOK[0m 
  test-import_inops.control.R...   11 tests [0;32mOK[0m Importing packages and registering methods...
  Done
  You can now access the functions using `stri.$`
  For conflicts report, packages order, and other attributes, run `attr.import(stri.)` 
  
  Checking for conflicting infix operators in the current environment...
  Placing infix operators in current environment...
  Done
  Checking for conflicting infix operators in the current environment...
  
  test-import_inops.control.R...   12 tests [0;32mOK[0m 
  test-import_inops.control.R...   12 tests [0;32mOK[0m Importing packages and registering methods...
  Done
  You can now access the functions using `stri.$`
  For conflicts report, packages order, and other attributes, run `attr.import(stri.)` 
  
  Checking for conflicting infix operators in the current environment...
  Placing infix operators in current environment...
  Done
  Checking for conflicting infix operators in the current environment...
  
  test-import_inops.control.R...   13 tests [0;32mOK[0m 
  test-import_inops.control.R...   13 tests [0;32mOK[0m 
  test-import_inops.control.R...   14 tests [0;32mOK[0m 
  test-import_inops.control.R...   14 tests [0;32mOK[0m 
  test-import_inops.control.R...   15 tests [0;32mOK[0m 
  test-import_inops.control.R...   15 tests [0;32mOK[0m 
  test-import_inops.control.R...   16 tests [0;32mOK[0m 
  test-import_inops.control.R...   16 tests [0;32mOK[0m 
  test-import_inops.control.R...   17 tests [0;32mOK[0m 
  test-import_inops.control.R...   17 tests [0;32mOK[0m 
  test-import_inops.control.R...   18 tests [0;32mOK[0m 
  test-import_inops.control.R...   18 tests [0;32mOK[0m 
  test-import_inops.control.R...   19 tests [0;32mOK[0m 
  test-import_inops.control.R...   19 tests [0;32mOK[0m 
  test-import_inops.control.R...   20 tests [0;32mOK[0m 
  test-import_inops.control.R...   20 tests [0;32mOK[0m 
  test-import_inops.control.R...   21 tests [0;32mOK[0m 
  test-import_inops.control.R...   21 tests [0;32mOK[0m 
  test-import_inops.control.R...   22 tests [0;32mOK[0m 
  test-import_inops.control.R...   22 tests [0;32mOK[0m 
  test-import_inops.control.R...   23 tests [0;32mOK[0m 
  test-import_inops.control.R...   23 tests [0;32mOK[0m 
  test-import_inops.control.R...   24 tests [0;32mOK[0m 
  test-import_inops.control.R...   24 tests [0;32mOK[0m 
  test-import_inops.control.R...   25 tests [0;32mOK[0m 
  test-import_inops.control.R...   25 tests [0;32mOK[0m 
  test-import_inops.control.R...   26 tests [0;32mOK[0m 
  test-import_inops.control.R...   26 tests [0;32mOK[0m Checking for conflicting infix operators in the current environment...
  Placing infix operators in current environment...
  Done
  Checking for conflicting infix operators in the current environment...
  
  test-import_inops.control.R...   27 tests [0;32mOK[0m 
  test-import_inops.control.R...   27 tests [0;32mOK[0m Checking for conflicting infix operators in the current environment...
  Placing infix operators in current environment...
  Done
  Checking for conflicting infix operators in the current environment...
  
  test-import_inops.control.R...   28 tests [0;32mOK[0m 
  test-import_inops.control.R...   28 tests [0;32mOK[0m 
  test-import_inops.control.R...   29 tests [0;32mOK[0m 
  test-import_inops.control.R...   29 tests [0;32mOK[0m 
  test-import_inops.control.R...   30 tests [0;32mOK[0m [0;34m0.4s[0m
  
  test-import_int.R.............    1 tests [0;32mOK[0m 
  test-import_int.R.............    2 tests [0;32mOK[0m 
  test-import_int.R.............    3 tests [0;32mOK[0m 
  test-import_int.R.............    4 tests [0;32mOK[0m 
  test-import_int.R.............    5 tests [0;32mOK[0m 
  test-import_int.R.............    6 tests [0;32mOK[0m 
  test-import_int.R.............    7 tests [0;32mOK[0m 
  test-import_int.R.............    8 tests [0;32mOK[0m 
  test-import_int.R.............    9 tests [0;32mOK[0m 
  test-import_int.R.............   10 tests [0;32mOK[0m 
  test-import_int.R.............   11 tests [0;32mOK[0m 
  test-import_int.R.............   12 tests [0;32mOK[0m [0;36m33ms[0m
  
  test-import_lock.R............    0 tests    Importing packages and registering methods...
  Done
  You can now access the functions using `stri.$`
  For conflicts report, packages order, and other attributes, run `attr.import(stri.)` 
  
  
  test-import_lock.R............    1 tests [0;32mOK[0m 
  test-import_lock.R............    1 tests [0;32mOK[0m Importing packages and registering methods...
  
  test-import_lock.R............    2 tests [0;32mOK[0m 
  test-import_lock.R............    2 tests [0;32mOK[0m Importing packages and registering methods...
  Done
  You can now access the functions using `stri.$`
  For conflicts report, packages order, and other attributes, run `attr.import(stri.)` 
  
  
  test-import_lock.R............    3 tests [0;32mOK[0m 
  test-import_lock.R............    3 tests [0;32mOK[0m Importing packages and registering methods...
  Done
  You can now access the functions using `stri.$`
  For conflicts report, packages order, and other attributes, run `attr.import(stri.)` 
  
  
  test-import_lock.R............    4 tests [0;32mOK[0m 
  test-import_lock.R............    4 tests [0;32mOK[0m Importing packages and registering methods...
  Done
  You can now access the functions using `stri.$`
  For conflicts report, packages order, and other attributes, run `attr.import(stri.)` 
  
  
  test-import_lock.R............    5 tests [0;32mOK[0m 
  test-import_lock.R............    5 tests [0;32mOK[0m Importing packages and registering methods...
  Done
  You can now access the functions using `stri.$`
  For conflicts report, packages order, and other attributes, run `attr.import(stri.)` 
  
  Importing packages and registering methods...
  Done
  You can now access the functions using `stri.$`
  For conflicts report, packages order, and other attributes, run `attr.import(stri.)` 
  
  
  test-import_lock.R............    6 tests [0;32mOK[0m 
  test-import_lock.R............    6 tests [0;32mOK[0m Importing packages and registering methods...
  Done
  You can now access the functions using `stri.$`
  For conflicts report, packages order, and other attributes, run `attr.import(stri.)` 
  
  
  test-import_lock.R............    7 tests [0;32mOK[0m 
  test-import_lock.R............    7 tests [0;32mOK[0m Checking for conflicting infix operators in the current environment...
  The following infix operators already exist in the current environment:
  %stri+%
  Overwriting existing infix operators...
  Placing infix operators in current environment...
  
  test-import_lock.R............    8 tests [0;32mOK[0m 
  test-import_lock.R............    8 tests [0;32mOK[0m 
  test-import_lock.R............    8 tests [0;32mOK[0m Checking for conflicting infix operators in the current environment...
  Placing infix operators in current environment...
  Done
  Checking for conflicting infix operators in the current environment...
  Placing infix operators in current environment...
  Done
  Checking for conflicting infix operators in the current environment...
  ALL prepared infix operators already exist in the current environment
  Overwriting existing infix operators...
  Placing infix operators in current environment...
  Done
  
  test-import_lock.R............    9 tests [0;32mOK[0m 
  test-import_lock.R............    9 tests [0;32mOK[0m 
  test-import_lock.R............   10 tests [0;32mOK[0m [0;34m0.3s[0m
  
  test-internal.R...............    1 tests [0;32mOK[0m 
  test-internal.R...............    2 tests [0;32mOK[0m 
  test-internal.R...............    3 tests [0;32mOK[0m 
  test-internal.R...............    4 tests [0;32mOK[0m 
  test-internal.R...............    5 tests [0;32mOK[0m [0;36m3ms[0m
  
  test-logic_ops.R..............    0 tests    
  test-logic_ops.R..............    0 tests    
  test-logic_ops.R..............    0 tests    
  test-logic_ops.R..............    0 tests    
  test-logic_ops.R..............    1 tests [0;32mOK[0m 
  test-logic_ops.R..............    1 tests [0;32mOK[0m 
  test-logic_ops.R..............    1 tests [0;32mOK[0m 
  test-logic_ops.R..............    1 tests [0;32mOK[0m 
  test-logic_ops.R..............    1 tests [0;32mOK[0m 
  test-logic_ops.R..............    2 tests [0;32mOK[0m 
  test-logic_ops.R..............    2 tests [0;32mOK[0m 
  test-logic_ops.R..............    2 tests [0;32mOK[0m 
  test-logic_ops.R..............    2 tests [0;32mOK[0m 
  test-logic_ops.R..............    2 tests [0;32mOK[0m 
  test-logic_ops.R..............    2 tests [0;32mOK[0m 
  test-logic_ops.R..............    3 tests [0;32mOK[0m 
  test-logic_ops.R..............    3 tests [0;32mOK[0m 
  test-logic_ops.R..............    3 tests [0;32mOK[0m 
  test-logic_ops.R..............    3 tests [0;32mOK[0m 
  test-logic_ops.R..............    4 tests [0;32mOK[0m 
  test-logic_ops.R..............    5 tests [0;32mOK[0m 
  test-logic_ops.R..............    6 tests [0;32mOK[0m 
  test-logic_ops.R..............    6 tests [0;32mOK[0m 
  test-logic_ops.R..............    6 tests [0;32mOK[0m 
  test-logic_ops.R..............    7 tests [0;32mOK[0m 
  test-logic_ops.R..............    8 tests [0;32mOK[0m 
  test-logic_ops.R..............    9 tests [0;32mOK[0m 
  test-logic_ops.R..............   10 tests [0;32mOK[0m 
  test-logic_ops.R..............   11 tests [0;32mOK[0m 
  test-logic_ops.R..............   12 tests [0;32mOK[0m 
  test-logic_ops.R..............   13 tests [0;32mOK[0m 
  test-logic_ops.R..............   14 tests [0;32mOK[0m 
  test-logic_ops.R..............   15 tests [0;32mOK[0m 
  test-logic_ops.R..............   15 tests [0;32mOK[0m 
  test-logic_ops.R..............   15 tests [0;32mOK[0m 
  test-logic_ops.R..............   16 tests [0;32mOK[0m 
  test-logic_ops.R..............   17 tests [0;32mOK[0m 
  test-logic_ops.R..............   18 tests [0;32mOK[0m 
  test-logic_ops.R..............   19 tests [0;32mOK[0m 
  test-logic_ops.R..............   20 tests [0;32mOK[0m 
  test-logic_ops.R..............   21 tests [0;32mOK[0m 
  test-logic_ops.R..............   22 tests [0;32mOK[0m 
  test-logic_ops.R..............   23 tests [0;32mOK[0m 
  test-logic_ops.R..............   24 tests [0;32mOK[0m 
  test-logic_ops.R..............   25 tests [0;32mOK[0m [0;36m18ms[0m
  
  test-matrix_ops.R.............    0 tests    
  test-matrix_ops.R.............    0 tests    
  test-matrix_ops.R.............    0 tests    
  test-matrix_ops.R.............    1 tests [0;32mOK[0m 
  test-matrix_ops.R.............    2 tests [0;32mOK[0m 
  test-matrix_ops.R.............    2 tests [0;32mOK[0m 
  test-matrix_ops.R.............    2 tests [0;32mOK[0m 
  test-matrix_ops.R.............    3 tests [0;32mOK[0m 
  test-matrix_ops.R.............    4 tests [0;32mOK[0m [0;36m4ms[0m
  
  test-pkgs.R...................    0 tests    
  test-pkgs.R...................    0 tests    
  test-pkgs.R...................    0 tests    
  test-pkgs.R...................    0 tests    
  test-pkgs.R...................    0 tests    
  test-pkgs.R...................    0 tests    
  test-pkgs.R...................    1 tests [0;32mOK[0m 
  test-pkgs.R...................    1 tests [0;32mOK[0m 
  test-pkgs.R...................    1 tests [0;32mOK[0m 
  test-pkgs.R...................    2 tests [0;32mOK[0m 
  test-pkgs.R...................    2 tests [0;32mOK[0m 
  test-pkgs.R...................    2 tests [0;32mOK[0m 
  test-pkgs.R...................    3 tests [0;32mOK[0m 
  test-pkgs.R...................    4 tests [0;32mOK[0m 
  test-pkgs.R...................    5 tests [0;32mOK[0m 
  test-pkgs.R...................    6 tests [0;32mOK[0m 
  test-pkgs.R...................    7 tests [0;32mOK[0m [0;36m47ms[0m
  
  test-pro.R....................    0 tests    
  test-pro.R....................    0 tests    
  test-pro.R....................    1 tests [0;32mOK[0m 
  test-pro.R....................    2 tests [0;32mOK[0m 
  test-pro.R....................    6 tests [0;32mOK[0m 
  test-pro.R....................    6 tests [0;32mOK[0m 
  test-pro.R....................    6 tests [0;32mOK[0m 
  test-pro.R....................    7 tests [0;32mOK[0m 
  test-pro.R....................    7 tests [0;32mOK[0m 
  test-pro.R....................    7 tests [0;32mOK[0m 
  test-pro.R....................    8 tests [0;32mOK[0m 
  test-pro.R....................    8 tests [0;32mOK[0m 
  test-pro.R....................    8 tests [0;32mOK[0m 
  test-pro.R....................    8 tests [0;32mOK[0m 
  test-pro.R....................    9 tests [0;32mOK[0m 
  test-pro.R....................    9 tests [0;32mOK[0m 
  test-pro.R....................    9 tests [0;32mOK[0m 
  test-pro.R....................   10 tests [0;32mOK[0m 
  test-pro.R....................   10 tests [0;32mOK[0m 
  test-pro.R....................   10 tests [0;32mOK[0m 
  test-pro.R....................   11 tests [0;32mOK[0m 
  test-pro.R....................   12 tests [0;32mOK[0m 
  test-pro.R....................   13 tests [0;32mOK[0m 
  test-pro.R....................   14 tests [0;32mOK[0m [0;36m21ms[0m
  
  test-pversion.R...............    1 tests [0;32mOK[0m 
  test-pversion.R...............    2 tests [0;32mOK[0m 
  test-pversion.R...............    3 tests [0;32mOK[0m [0;36m11ms[0m
  
  test-report_inops.R...........    0 tests    
  test-report_inops.R...........    1 tests [0;32mOK[0m 
  test-report_inops.R...........    1 tests [0;32mOK[0m 
  test-report_inops.R...........    2 tests [0;32mOK[0m 
  test-report_inops.R...........    3 tests [0;32mOK[0m 
  test-report_inops.R...........    4 tests [0;32mOK[0m 
  test-report_inops.R...........    5 tests [0;32mOK[0m 
  test-report_inops.R...........    5 tests [0;32mOK[0m 
  test-report_inops.R...........    6 tests [0;32mOK[0m 
  test-report_inops.R...........    7 tests [0;32mOK[0m 
  test-report_inops.R...........    8 tests [0;32mOK[0m 
  test-report_inops.R...........    9 tests [0;32mOK[0m 
  test-report_inops.R...........    9 tests [0;32mOK[0m 
  test-report_inops.R...........   10 tests [0;32mOK[0m 
  test-report_inops.R...........   11 tests [0;32mOK[0m 
  test-report_inops.R...........   12 tests [0;32mOK[0m 
  test-report_inops.R...........   12 tests [0;32mOK[0m 
  test-report_inops.R...........   13 tests [0;32mOK[0m 
  test-report_inops.R...........   13 tests [0;32mOK[0m 
  test-report_inops.R...........   14 tests [0;32mOK[0m 
  test-report_inops.R...........   14 tests [0;32mOK[0m 
  test-report_inops.R...........   15 tests [0;32mOK[0m 
  test-report_inops.R...........   15 tests [0;32mOK[0m 
  test-report_inops.R...........   15 tests [0;32mOK[0m 
  test-report_inops.R...........   16 tests [0;32mOK[0m [0;34m0.4s[0m
  
  test-s_pattern.R..............    0 tests    
  test-s_pattern.R..............    1 tests [0;32mOK[0m 
  test-s_pattern.R..............    1 tests [0;32mOK[0m 
  test-s_pattern.R..............    2 tests [0;32mOK[0m 
  test-s_pattern.R..............    2 tests [0;32mOK[0m 
  test-s_pattern.R..............    3 tests [0;32mOK[0m 
  test-s_pattern.R..............    3 tests [0;32mOK[0m 
  test-s_pattern.R..............    4 tests [0;32mOK[0m 
  test-s_pattern.R..............    4 tests [0;32mOK[0m 
  test-s_pattern.R..............    5 tests [0;32mOK[0m 
  test-s_pattern.R..............    5 tests [0;32mOK[0m 
  test-s_pattern.R..............    6 tests [0;32mOK[0m 
  test-s_pattern.R..............    6 tests [0;32mOK[0m 
  test-s_pattern.R..............    7 tests [0;32mOK[0m 
  test-s_pattern.R..............    7 tests [0;32mOK[0m 
  test-s_pattern.R..............    8 tests [0;32mOK[0m [0;36m6ms[0m
  
  test-source_selection.R.......    0 tests    
  test-source_selection.R.......    0 tests    
  test-source_selection.R.......    0 tests    
  test-source_selection.R.......    0 tests    
  test-source_selection.R.......    0 tests    Sourcing script ... 
  
  Done
  
  test-source_selection.R.......    1 tests [0;32mOK[0m 
  test-source_selection.R.......    1 tests [0;32mOK[0m 
  test-source_selection.R.......    1 tests [0;32mOK[0m Sourcing script ... 
  
  Done
  
  test-source_selection.R.......    2 tests [0;32mOK[0m 
  test-source_selection.R.......    2 tests [0;32mOK[0m Sourcing script ... 
  
  Done
  
  test-source_selection.R.......    3 tests [0;32mOK[0m 
  test-source_selection.R.......    3 tests [0;32mOK[0m Sourcing script ... 
  
  Done
  
  test-source_selection.R.......    4 tests [0;32mOK[0m 
  test-source_selection.R.......    4 tests [0;32mOK[0m Sourcing script ... 
  
  Done
  
  test-source_selection.R.......    5 tests [0;32mOK[0m 
  test-source_selection.R.......    5 tests [0;32mOK[0m Sourcing script ... 
  
  Done
  
  test-source_selection.R.......    6 tests [0;32mOK[0m 
  test-source_selection.R.......    6 tests [0;32mOK[0m Sourcing script ... 
  
  Done
  
  test-source_selection.R.......    7 tests [0;32mOK[0m 
  test-source_selection.R.......    7 tests [0;32mOK[0m Sourcing script ... 
  
  Done
  
  test-source_selection.R.......    8 tests [0;32mOK[0m 
  test-source_selection.R.......    8 tests [0;32mOK[0m Sourcing script ... 
  
  Done
  
  test-source_selection.R.......    9 tests [0;32mOK[0m 
  test-source_selection.R.......    9 tests [0;32mOK[0m Sourcing script ... 
  
  Done
  
  test-source_selection.R.......    9 tests [0;32mOK[0m 
  test-source_selection.R.......   10 tests [0;32mOK[0m 
  test-source_selection.R.......   11 tests [0;32mOK[0m 
  test-source_selection.R.......   12 tests [0;32mOK[0m 
  test-source_selection.R.......   13 tests [0;32mOK[0m Sourcing script ... 
  
  
  test-source_selection.R.......   14 tests [0;32mOK[0m 
  test-source_selection.R.......   15 tests [0;32mOK[0m 
  test-source_selection.R.......   16 tests [0;32mOK[0m 
  test-source_selection.R.......   17 tests [0;32mOK[0m 
  test-source_selection.R.......   18 tests [0;32mOK[0m 
  test-source_selection.R.......   19 tests [0;32mOK[0m Sourcing script ... 
  
  
  test-source_selection.R.......   20 tests [0;32mOK[0m 
  test-source_selection.R.......   21 tests [0;32mOK[0m 
  test-source_selection.R.......   22 tests [0;32mOK[0m [0;36m12ms[0m
  
  test-str_arithmetic.R.........    0 tests    
  test-str_arithmetic.R.........    0 tests    
  test-str_arithmetic.R.........    0 tests    
  test-str_arithmetic.R.........    0 tests    
  test-str_arithmetic.R.........    0 tests    
  test-str_arithmetic.R.........    0 tests    
  test-str_arithmetic.R.........    0 tests    
  test-str_arithmetic.R.........    0 tests    
  test-str_arithmetic.R.........    1 tests [0;32mOK[0m 
  test-str_arithmetic.R.........    2 tests [0;32mOK[0m 
  test-str_arithmetic.R.........    3 tests [0;32mOK[0m 
  test-str_arithmetic.R.........    3 tests [0;32mOK[0m 
  test-str_arithmetic.R.........    3 tests [0;32mOK[0m 
  test-str_arithmetic.R.........    3 tests [0;32mOK[0m 
  test-str_arithmetic.R.........    3 tests [0;32mOK[0m 
  test-str_arithmetic.R.........    4 tests [0;32mOK[0m 
  test-str_arithmetic.R.........    5 tests [0;32mOK[0m 
  test-str_arithmetic.R.........    6 tests [0;32mOK[0m 
  test-str_arithmetic.R.........    6 tests [0;32mOK[0m 
  test-str_arithmetic.R.........    6 tests [0;32mOK[0m 
  test-str_arithmetic.R.........    7 tests [0;32mOK[0m 
  test-str_arithmetic.R.........    8 tests [0;32mOK[0m 
  test-str_arithmetic.R.........    9 tests [0;32mOK[0m 
  test-str_arithmetic.R.........    9 tests [0;32mOK[0m 
  test-str_arithmetic.R.........    9 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   10 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   11 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   12 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   13 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   14 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   15 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   15 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   15 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   15 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   15 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   15 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   15 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   15 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   16 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   17 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   18 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   18 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   18 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   19 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   20 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   21 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   22 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   23 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   24 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   24 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   24 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   25 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   26 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   27 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   27 tests [0;32mOK[0m [1] "abcdefghijklm" "nopqrstuvwxyz"
  
  test-str_arithmetic.R.........   27 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   27 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   27 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   27 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   27 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   28 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   29 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   30 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   31 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   32 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   33 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   34 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   35 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   35 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   36 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   37 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   38 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   39 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   40 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   41 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   42 tests [0;32mOK[0m 
  test-str_arithmetic.R.........   43 tests [0;32mOK[0m [0;36m35ms[0m
  
  test-str_search.R.............    0 tests    
  test-str_search.R.............    0 tests    
  test-str_search.R.............    0 tests    
  test-str_search.R.............    0 tests    
  test-str_search.R.............    0 tests    
  test-str_search.R.............    0 tests    ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search.R<32--57>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
   call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
   call| -->        negate = TRUE)) 
  
  test-str_search.R.............  336 tests [0;32mOK[0m 
  test-str_search.R.............  336 tests [0;32mOK[0m 
  test-str_search.R.............  337 tests [0;32mOK[0m 
  test-str_search.R.............  338 tests [0;32mOK[0m 
  test-str_search.R.............  339 tests [0;32mOK[0m 
  test-str_search.R.............  340 tests [0;32mOK[0m 
  test-str_search.R.............  341 tests [0;32mOK[0m 
  test-str_search.R.............  342 tests [0;32mOK[0m 
  test-str_search.R.............  343 tests [0;32mOK[0m 
  test-str_search.R.............  344 tests [0;32mOK[0m 
  test-str_search.R.............  345 tests [0;32mOK[0m 
  test-str_search.R.............  346 tests [0;32mOK[0m 
  test-str_search.R.............  346 tests [0;32mOK[0m 
  test-str_search.R.............  346 tests [0;32mOK[0m 
  test-str_search.R.............  347 tests [0;32mOK[0m 
  test-str_search.R.............  348 tests [0;32mOK[0m 
  test-str_search.R.............  349 tests [0;32mOK[0m 
  test-str_search.R.............  350 tests [0;32mOK[0m 
  test-str_search.R.............  351 tests [0;32mOK[0m 
  test-str_search.R.............  352 tests [0;32mOK[0m 
  test-str_search.R.............  352 tests [0;32mOK[0m 
  test-str_search.R.............  352 tests [0;32mOK[0m 
  test-str_search.R.............  353 tests [0;32mOK[0m 
  test-str_search.R.............  354 tests [0;32mOK[0m 
  test-str_search.R.............  355 tests [0;32mOK[0m 
  test-str_search.R.............  356 tests [0;32mOK[0m 
  test-str_search.R.............  356 tests [0;32mOK[0m 
  test-str_search.R.............  356 tests [0;32mOK[0m 
  test-str_search.R.............  356 tests [0;32mOK[0m 
  test-str_search.R.............  356 tests [0;32mOK[0m 
  test-str_search.R.............  356 tests [0;32mOK[0m 
  test-str_search.R.............  356 tests [0;32mOK[0m 
  test-str_search.R.............  356 tests [0;32mOK[0m 
  test-str_search.R.............  357 tests [0;32mOK[0m 
  test-str_search.R.............  358 tests [0;32mOK[0m 
  test-str_search.R.............  358 tests [0;32mOK[0m 
  test-str_search.R.............  358 tests [0;32mOK[0m 
  test-str_search.R.............  359 tests [0;32mOK[0m 
  test-str_search.R.............  360 tests [0;32mOK[0m 
  test-str_search.R.............  361 tests [0;32mOK[0m 
  test-str_search.R.............  362 tests [0;32mOK[0m 
  test-str_search.R.............  362 tests [0;32mOK[0m 
  test-str_search.R.............  362 tests [0;32mOK[0m 
  test-str_search.R.............  363 tests [0;32mOK[0m 
  test-str_search.R.............  364 tests [0;32mOK[0m 
  test-str_search.R.............  365 tests [0;32mOK[0m 
  test-str_search.R.............  366 tests [0;32mOK[0m [0;34m4.3s[0m
  
  test-str_search_at.R..........    0 tests    
  test-str_search_at.R..........    0 tests    
  test-str_search_at.R..........    0 tests    
  test-str_search_at.R..........    0 tests    
  test-str_search_at.R..........    0 tests    
  test-str_search_at.R..........    0 tests    ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
   call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-str_search_at.R<31--72>
   call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
   call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
  
  test-str_search_at.R..........  672 tests [0;32mOK[0m 
  test-str_search_at.R..........  672 tests [0;32mOK[0m 
  test-str_search_at.R..........  672 tests [0;32mOK[0m 
  test-str_search_at.R..........  673 tests [0;32mOK[0m 
  test-str_search_at.R..........  673 tests [0;32mOK[0m 
  test-str_search_at.R..........  674 tests [0;32mOK[0m 
  test-str_search_at.R..........  674 tests [0;32mOK[0m 
  test-str_search_at.R..........  675 tests [0;32mOK[0m 
  test-str_search_at.R..........  675 tests [0;32mOK[0m 
  test-str_search_at.R..........  676 tests [0;32mOK[0m 
  test-str_search_at.R..........  677 tests [0;32mOK[0m 
  test-str_search_at.R..........  678 tests [0;32mOK[0m 
  test-str_search_at.R..........  679 tests [0;32mOK[0m 
  test-str_search_at.R..........  680 tests [0;32mOK[0m [0;34m8.9s[0m
  
  test-str_subset_ops.R.........    0 tests    
  test-str_subset_ops.R.........    0 tests    
  test-str_subset_ops.R.........    0 tests    
  test-str_subset_ops.R.........    0 tests    [1] "abcdefghijklm" "nopqrstuvwxyz" "abcdefghijklm" "nopqrstuvwxyz"
  [5] "abcdefghijklm" "nopqrstuvwxyz" "abcdefghijklm"
  
  test-str_subset_ops.R.........    0 tests    
  test-str_subset_ops.R.........    0 tests    
  test-str_subset_ops.R.........    1 tests [0;32mOK[0m 
  test-str_subset_ops.R.........    1 tests [0;32mOK[0m 
  test-str_subset_ops.R.........    1 tests [0;32mOK[0m 
  test-str_subset_ops.R.........    1 tests [0;32mOK[0m 
  test-str_subset_ops.R.........    1 tests [0;32mOK[0m 
  test-str_subset_ops.R.........    2 tests [0;32mOK[0m 
  test-str_subset_ops.R.........    3 tests [0;32mOK[0m 
  test-str_subset_ops.R.........    3 tests [0;32mOK[0m 
  test-str_subset_ops.R.........    3 tests [0;32mOK[0m 
  test-str_subset_ops.R.........    3 tests [0;32mOK[0m 
  test-str_subset_ops.R.........    4 tests [0;32mOK[0m 
  test-str_subset_ops.R.........    4 tests [0;32mOK[0m [1] "abcdefghijklm" "nopqrstuvwxyz" "abcdefghijklm" "nopqrstuvwxyz"
  
  test-str_subset_ops.R.........    4 tests [0;32mOK[0m 
  test-str_subset_ops.R.........    4 tests [0;32mOK[0m 
  test-str_subset_ops.R.........    5 tests [0;32mOK[0m 
  test-str_subset_ops.R.........    6 tests [0;32mOK[0m 
  test-str_subset_ops.R.........    7 tests [0;32mOK[0m 
  test-str_subset_ops.R.........    8 tests [0;32mOK[0m 
  test-str_subset_ops.R.........    9 tests [0;32mOK[0m 
  test-str_subset_ops.R.........   10 tests [0;32mOK[0m 
  test-str_subset_ops.R.........   11 tests [0;32mOK[0m 
  test-str_subset_ops.R.........   12 tests [0;32mOK[0m 
  test-str_subset_ops.R.........   12 tests [0;32mOK[0m 
  test-str_subset_ops.R.........   13 tests [0;32mOK[0m 
  test-str_subset_ops.R.........   14 tests [0;32mOK[0m [0;36m10ms[0m
  
  test-strcut.R.................    0 tests    
  test-strcut.R.................    0 tests    [1] "123456789" "123456789" "123456789" "123456789" "123456789" "123456789"
  [7] "123456789" "123456789" "123456789"
  
  test-strcut.R.................    0 tests    
  test-strcut.R.................    0 tests    
  test-strcut.R.................    0 tests    
  test-strcut.R.................    1 tests [0;32mOK[0m 
  test-strcut.R.................    1 tests [0;32mOK[0m  [1] "12345678910" "12345678910" "12345678910" "12345678910" "12345678910"
   [6] "12345678910" "12345678910" "12345678910" "12345678910" "12345678910"
  
  test-strcut.R.................    1 tests [0;32mOK[0m 
  test-strcut.R.................    1 tests [0;32mOK[0m 
  test-strcut.R.................    1 tests [0;32mOK[0m 
  test-strcut.R.................    2 tests [0;32mOK[0m 
  test-strcut.R.................    2 tests [0;32mOK[0m 
  test-strcut.R.................    2 tests [0;32mOK[0m 
  test-strcut.R.................    2 tests [0;32mOK[0m 
  test-strcut.R.................    3 tests [0;32mOK[0m 
  test-strcut.R.................    3 tests [0;32mOK[0m 
  test-strcut.R.................    3 tests [0;32mOK[0m 
  test-strcut.R.................    3 tests [0;32mOK[0m 
  test-strcut.R.................    4 tests [0;32mOK[0m 
  test-strcut.R.................    4 tests [0;32mOK[0m 
  test-strcut.R.................    4 tests [0;32mOK[0m 
  test-strcut.R.................    4 tests [0;32mOK[0m 
  test-strcut.R.................    5 tests [0;32mOK[0m 
  test-strcut.R.................    5 tests [0;32mOK[0m 
  test-strcut.R.................    5 tests [0;32mOK[0m 
  test-strcut.R.................    5 tests [0;32mOK[0m 
  test-strcut.R.................    6 tests [0;32mOK[0m 
  test-strcut.R.................    6 tests [0;32mOK[0m 
  test-strcut.R.................    6 tests [0;32mOK[0m 
  test-strcut.R.................    7 tests [0;32mOK[0m 
  test-strcut.R.................    7 tests [0;32mOK[0m 
  test-strcut.R.................    7 tests [0;32mOK[0m 
  test-strcut.R.................    8 tests [0;32mOK[0m 
  test-strcut.R.................    8 tests [0;32mOK[0m 
  test-strcut.R.................    8 tests [0;32mOK[0m 
  test-strcut.R.................    9 tests [0;32mOK[0m 
  test-strcut.R.................    9 tests [0;32mOK[0m 
  test-strcut.R.................   10 tests [0;32mOK[0m 
  test-strcut.R.................   11 tests [0;32mOK[0m 
  test-strcut.R.................   12 tests [0;32mOK[0m 
  test-strcut.R.................   13 tests [0;32mOK[0m 
  test-strcut.R.................   14 tests [0;32mOK[0m 
  test-strcut.R.................   15 tests [0;32mOK[0m 
  test-strcut.R.................   16 tests [0;32mOK[0m 
  test-strcut.R.................   17 tests [0;32mOK[0m 
  test-strcut.R.................   18 tests [0;32mOK[0m 
  test-strcut.R.................   19 tests [0;32mOK[0m 
  test-strcut.R.................   20 tests [0;32mOK[0m 
  test-strcut.R.................   20 tests [0;32mOK[0m 
  test-strcut.R.................   21 tests [0;32mOK[0m 
  test-strcut.R.................   22 tests [0;32mOK[0m 
  test-strcut.R.................   23 tests [0;32mOK[0m 
  test-strcut.R.................   24 tests [0;32mOK[0m 
  test-strcut.R.................   25 tests [0;32mOK[0m 
  test-strcut.R.................   26 tests [0;32mOK[0m 
  test-strcut.R.................   27 tests [0;32mOK[0m 
  test-strcut.R.................   28 tests [0;32mOK[0m 
  test-strcut.R.................   29 tests [0;32mOK[0m 
  test-strcut.R.................   29 tests [0;32mOK[0m 
  test-strcut.R.................   30 tests [0;32mOK[0m 
  test-strcut.R.................   31 tests [0;32mOK[0m 
  test-strcut.R.................   32 tests [0;32mOK[0m 
  test-strcut.R.................   33 tests [0;32mOK[0m 
  test-strcut.R.................   34 tests [0;32mOK[0m 
  test-strcut.R.................   35 tests [0;32mOK[0m 
  test-strcut.R.................   36 tests [0;32mOK[0m 
  test-strcut.R.................   37 tests [0;32mOK[0m 
  test-strcut.R.................   38 tests [0;32mOK[0m 
  test-strcut.R.................   39 tests [0;32mOK[0m 
  test-strcut.R.................   39 tests [0;32mOK[0m 
  test-strcut.R.................   40 tests [0;32mOK[0m 
  test-strcut.R.................   41 tests [0;32mOK[0m 
  test-strcut.R.................   42 tests [0;32mOK[0m 
  test-strcut.R.................   43 tests [0;32mOK[0m 
  test-strcut.R.................   44 tests [0;32mOK[0m 
  test-strcut.R.................   45 tests [0;32mOK[0m 
  test-strcut.R.................   46 tests [0;32mOK[0m 
  test-strcut.R.................   47 tests [0;32mOK[0m 
  test-strcut.R.................   48 tests [0;32mOK[0m 
  test-strcut.R.................   49 tests [0;32mOK[0m 
  test-strcut.R.................   50 tests [0;32mOK[0m 
  test-strcut.R.................   51 tests [0;32mOK[0m 
  test-strcut.R.................   52 tests [0;32mOK[0m [0;36m39ms[0m
  
  test-strfind.R................    0 tests    
  test-strfind.R................    0 tests    
  test-strfind.R................    0 tests    
  test-strfind.R................    0 tests    
  test-strfind.R................    0 tests    
  test-strfind.R................    0 tests    
  test-strfind.R................    0 tests    
  test-strfind.R................    1 tests [0;32mOK[0m 
  test-strfind.R................    2 tests [0;32mOK[0m 
  test-strfind.R................    2 tests [0;32mOK[0m [1] "abcdefghijklm" "nopqrstuvwxyz" "ABCDEFGHIJKLM" "NOPQRSTUVWXYZ"
  
  test-strfind.R................    2 tests [0;32mOK[0m 
  test-strfind.R................    2 tests [0;32mOK[0m 
  test-strfind.R................    2 tests [0;32mOK[0m 
  test-strfind.R................    3 tests [0;32mOK[0m 
  test-strfind.R................    4 tests [0;32mOK[0m 
  test-strfind.R................    4 tests [0;32mOK[0m 
  test-strfind.R................    4 tests [0;32mOK[0m 
  test-strfind.R................    5 tests [0;32mOK[0m 
  test-strfind.R................    5 tests [0;32mOK[0m 
  test-strfind.R................    5 tests [0;32mOK[0m 
  test-strfind.R................    5 tests [0;32mOK[0m 
  test-strfind.R................    6 tests [0;32mOK[0m 
  test-strfind.R................    6 tests [0;32mOK[0m 
  test-strfind.R................    6 tests [0;32mOK[0m 
  test-strfind.R................    6 tests [0;32mOK[0m 
  test-strfind.R................    7 tests [0;32mOK[0m 
  test-strfind.R................    7 tests [0;32mOK[0m 
  test-strfind.R................    7 tests [0;32mOK[0m 
  test-strfind.R................    7 tests [0;32mOK[0m 
  test-strfind.R................    7 tests [0;32mOK[0m 
  test-strfind.R................    8 tests [0;32mOK[0m 
  test-strfind.R................    9 tests [0;32mOK[0m 
  test-strfind.R................    9 tests [0;32mOK[0m [1] "abcdefghijklm" "nopqrstuvwxyz" "ABCDEFGHIJKLM" "NOPQRSTUVWXYZ"
  
  test-strfind.R................    9 tests [0;32mOK[0m 
  test-strfind.R................    9 tests [0;32mOK[0m 
  test-strfind.R................    9 tests [0;32mOK[0m 
  test-strfind.R................   10 tests [0;32mOK[0m 
  test-strfind.R................   11 tests [0;32mOK[0m 
  test-strfind.R................   11 tests [0;32mOK[0m 
  test-strfind.R................   11 tests [0;32mOK[0m 
  test-strfind.R................   12 tests [0;32mOK[0m 
  test-strfind.R................   12 tests [0;32mOK[0m 
  test-strfind.R................   12 tests [0;32mOK[0m 
  test-strfind.R................   12 tests [0;32mOK[0m 
  test-strfind.R................   13 tests [0;32mOK[0m 
  test-strfind.R................   13 tests [0;32mOK[0m 
  test-strfind.R................   13 tests [0;32mOK[0m 
  test-strfind.R................   13 tests [0;32mOK[0m 
  test-strfind.R................   14 tests [0;32mOK[0m 
  test-strfind.R................   14 tests [0;32mOK[0m  [1] "0123456789" "0123456789" "0123456789" "0123456789" "0123456789"
   [6] "0123456789" "0123456789" "0123456789" "0123456789" "0123456789"
  
  test-strfind.R................   14 tests [0;32mOK[0m 
  test-strfind.R................   14 tests [0;32mOK[0m 
  test-strfind.R................   14 tests [0;32mOK[0m 
  test-strfind.R................   14 tests [0;32mOK[0m 
  test-strfind.R................   14 tests [0;32mOK[0m 
  test-strfind.R................   14 tests [0;32mOK[0m 
  test-strfind.R................   14 tests [0;32mOK[0m 
  test-strfind.R................   15 tests [0;32mOK[0m 
  test-strfind.R................   15 tests [0;32mOK[0m  [1] "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa"
   [6] "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa"
  
  test-strfind.R................   15 tests [0;32mOK[0m 
  test-strfind.R................   15 tests [0;32mOK[0m 
  test-strfind.R................   15 tests [0;32mOK[0m 
  test-strfind.R................   15 tests [0;32mOK[0m 
  test-strfind.R................   15 tests [0;32mOK[0m 
  test-strfind.R................   15 tests [0;32mOK[0m 
  test-strfind.R................   15 tests [0;32mOK[0m 
  test-strfind.R................   16 tests [0;32mOK[0m 
  test-strfind.R................   16 tests [0;32mOK[0m  [1] "ýýýýýýýýýý" "ýýýýýýýýýý" "ýýýýýýýýýý" "ýýýýýýýýýý" "ýýýýýýýýýý"
   [6] "ýýýýýýýýýý" "ýýýýýýýýýý" "ýýýýýýýýýý" "ýýýýýýýýýý" "ýýýýýýýýýý"
  
  test-strfind.R................   16 tests [0;32mOK[0m 
  test-strfind.R................   16 tests [0;32mOK[0m 
  test-strfind.R................   16 tests [0;32mOK[0m 
  test-strfind.R................   16 tests [0;32mOK[0m 
  test-strfind.R................   16 tests [0;32mOK[0m 
  test-strfind.R................   16 tests [0;32mOK[0m 
  test-strfind.R................   16 tests [0;32mOK[0m 
  test-strfind.R................   17 tests [0;32mOK[0m 
  test-strfind.R................   17 tests [0;32mOK[0m  [1] "a a a a a a a a a a" "a a a a a a a a a a" "a a a a a a a a a a"
   [4] "a a a a a a a a a a" "a a a a a a a a a a" "a a a a a a a a a a"
   [7] "a a a a a a a a a a" "a a a a a a a a a a" "a a a a a a a a a a"
  [10] "a a a a a a a a a a"
  
  test-strfind.R................   17 tests [0;32mOK[0m 
  test-strfind.R................   17 tests [0;32mOK[0m 
  test-strfind.R................   17 tests [0;32mOK[0m 
  test-strfind.R................   17 tests [0;32mOK[0m 
  test-strfind.R................   17 tests [0;32mOK[0m 
  test-strfind.R................   17 tests [0;32mOK[0m 
  test-strfind.R................   17 tests [0;32mOK[0m 
  test-strfind.R................   18 tests [0;32mOK[0m 
  test-strfind.R................   18 tests [0;32mOK[0m  [1] "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa"
   [6] "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa"
  
  test-strfind.R................   18 tests [0;32mOK[0m 
  test-strfind.R................   18 tests [0;32mOK[0m 
  test-strfind.R................   18 tests [0;32mOK[0m 
  test-strfind.R................   18 tests [0;32mOK[0m 
  test-strfind.R................   18 tests [0;32mOK[0m 
  test-strfind.R................   18 tests [0;32mOK[0m 
  test-strfind.R................   18 tests [0;32mOK[0m 
  test-strfind.R................   19 tests [0;32mOK[0m 
  test-strfind.R................   19 tests [0;32mOK[0m 
  test-strfind.R................   19 tests [0;32mOK[0m 
  test-strfind.R................   19 tests [0;32mOK[0m 
  test-strfind.R................   19 tests [0;32mOK[0m 
  test-strfind.R................   19 tests [0;32mOK[0m 
  test-strfind.R................   19 tests [0;32mOK[0m 
  test-strfind.R................   19 tests [0;32mOK[0m 
  test-strfind.R................   19 tests [0;32mOK[0m 
  test-strfind.R................   20 tests [0;32mOK[0m 
  test-strfind.R................   20 tests [0;32mOK[0m 
  test-strfind.R................   20 tests [0;32mOK[0m 
  test-strfind.R................   20 tests [0;32mOK[0m 
  test-strfind.R................   20 tests [0;32mOK[0m 
  test-strfind.R................   20 tests [0;32mOK[0m ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<198--221>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  
  test-strfind.R................  860 tests [0;32mOK[0m 
  test-strfind.R................  860 tests [0;32mOK[0m 
  test-strfind.R................  860 tests [0;32mOK[0m 
  test-strfind.R................  860 tests [0;32mOK[0m 
  test-strfind.R................  860 tests [0;32mOK[0m 
  test-strfind.R................  861 tests [0;32mOK[0m 
  test-strfind.R................  862 tests [0;32mOK[0m 
  test-strfind.R................  862 tests [0;32mOK[0m [1] "abcdefghijklm" "nopqrstuvwxyz" "ABCDEFGHIJKLM" "NOPQRSTUVWXYZ"
  
  test-strfind.R................  862 tests [0;32mOK[0m 
  test-strfind.R................  862 tests [0;32mOK[0m 
  test-strfind.R................  862 tests [0;32mOK[0m 
  test-strfind.R................  863 tests [0;32mOK[0m 
  test-strfind.R................  864 tests [0;32mOK[0m 
  test-strfind.R................  864 tests [0;32mOK[0m 
  test-strfind.R................  864 tests [0;32mOK[0m 
  test-strfind.R................  865 tests [0;32mOK[0m 
  test-strfind.R................  865 tests [0;32mOK[0m 
  test-strfind.R................  865 tests [0;32mOK[0m 
  test-strfind.R................  865 tests [0;32mOK[0m 
  test-strfind.R................  866 tests [0;32mOK[0m 
  test-strfind.R................  866 tests [0;32mOK[0m 
  test-strfind.R................  866 tests [0;32mOK[0m 
  test-strfind.R................  866 tests [0;32mOK[0m 
  test-strfind.R................  866 tests [0;32mOK[0m 
  test-strfind.R................  866 tests [0;32mOK[0m ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<288--311>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  
  test-strfind.R................ 1706 tests [0;32mOK[0m 
  test-strfind.R................ 1706 tests [0;32mOK[0m 
  test-strfind.R................ 1706 tests [0;32mOK[0m 
  test-strfind.R................ 1706 tests [0;32mOK[0m 
  test-strfind.R................ 1706 tests [0;32mOK[0m 
  test-strfind.R................ 1707 tests [0;32mOK[0m 
  test-strfind.R................ 1708 tests [0;32mOK[0m 
  test-strfind.R................ 1708 tests [0;32mOK[0m [1] "abcdefghijklm" "nopqrstuvwxyz" "ABCDEFGHIJKLM" "NOPQRSTUVWXYZ"
  
  test-strfind.R................ 1708 tests [0;32mOK[0m 
  test-strfind.R................ 1708 tests [0;32mOK[0m 
  test-strfind.R................ 1708 tests [0;32mOK[0m 
  test-strfind.R................ 1709 tests [0;32mOK[0m 
  test-strfind.R................ 1710 tests [0;32mOK[0m 
  test-strfind.R................ 1710 tests [0;32mOK[0m 
  test-strfind.R................ 1710 tests [0;32mOK[0m 
  test-strfind.R................ 1711 tests [0;32mOK[0m 
  test-strfind.R................ 1711 tests [0;32mOK[0m 
  test-strfind.R................ 1711 tests [0;32mOK[0m 
  test-strfind.R................ 1711 tests [0;32mOK[0m 
  test-strfind.R................ 1712 tests [0;32mOK[0m 
  test-strfind.R................ 1712 tests [0;32mOK[0m 
  test-strfind.R................ 1712 tests [0;32mOK[0m 
  test-strfind.R................ 1712 tests [0;32mOK[0m 
  test-strfind.R................ 1712 tests [0;32mOK[0m 
  test-strfind.R................ 1712 tests [0;32mOK[0m 
  test-strfind.R................ 1713 tests [0;32mOK[0m 
  test-strfind.R................ 1713 tests [0;32mOK[0m 
  test-strfind.R................ 1713 tests [0;32mOK[0m 
  test-strfind.R................ 1713 tests [0;32mOK[0m 
  test-strfind.R................ 1713 tests [0;32mOK[0m 
  test-strfind.R................ 1714 tests [0;32mOK[0m 
  test-strfind.R................ 1715 tests [0;32mOK[0m 
  test-strfind.R................ 1715 tests [0;32mOK[0m [1] "abcdefghijklm" "nopqrstuvwxyz" "ABCDEFGHIJKLM" "NOPQRSTUVWXYZ"
  
  test-strfind.R................ 1715 tests [0;32mOK[0m 
  test-strfind.R................ 1715 tests [0;32mOK[0m 
  test-strfind.R................ 1715 tests [0;32mOK[0m 
  test-strfind.R................ 1716 tests [0;32mOK[0m 
  test-strfind.R................ 1717 tests [0;32mOK[0m 
  test-strfind.R................ 1717 tests [0;32mOK[0m 
  test-strfind.R................ 1717 tests [0;32mOK[0m 
  test-strfind.R................ 1718 tests [0;32mOK[0m 
  test-strfind.R................ 1718 tests [0;32mOK[0m 
  test-strfind.R................ 1718 tests [0;32mOK[0m 
  test-strfind.R................ 1718 tests [0;32mOK[0m 
  test-strfind.R................ 1719 tests [0;32mOK[0m 
  test-strfind.R................ 1719 tests [0;32mOK[0m 
  test-strfind.R................ 1719 tests [0;32mOK[0m 
  test-strfind.R................ 1719 tests [0;32mOK[0m 
  test-strfind.R................ 1719 tests [0;32mOK[0m 
  test-strfind.R................ 1719 tests [0;32mOK[0m ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<426--449>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  
  test-strfind.R................ 2559 tests [0;32mOK[0m 
  test-strfind.R................ 2559 tests [0;32mOK[0m 
  test-strfind.R................ 2559 tests [0;32mOK[0m 
  test-strfind.R................ 2559 tests [0;32mOK[0m 
  test-strfind.R................ 2559 tests [0;32mOK[0m 
  test-strfind.R................ 2560 tests [0;32mOK[0m 
  test-strfind.R................ 2561 tests [0;32mOK[0m 
  test-strfind.R................ 2561 tests [0;32mOK[0m [1] "abcdefghijklm" "nopqrstuvwxyz" "ABCDEFGHIJKLM" "NOPQRSTUVWXYZ"
  
  test-strfind.R................ 2561 tests [0;32mOK[0m 
  test-strfind.R................ 2561 tests [0;32mOK[0m 
  test-strfind.R................ 2561 tests [0;32mOK[0m 
  test-strfind.R................ 2562 tests [0;32mOK[0m 
  test-strfind.R................ 2563 tests [0;32mOK[0m 
  test-strfind.R................ 2563 tests [0;32mOK[0m 
  test-strfind.R................ 2563 tests [0;32mOK[0m 
  test-strfind.R................ 2564 tests [0;32mOK[0m 
  test-strfind.R................ 2564 tests [0;32mOK[0m 
  test-strfind.R................ 2564 tests [0;32mOK[0m 
  test-strfind.R................ 2564 tests [0;32mOK[0m 
  test-strfind.R................ 2565 tests [0;32mOK[0m 
  test-strfind.R................ 2565 tests [0;32mOK[0m 
  test-strfind.R................ 2565 tests [0;32mOK[0m 
  test-strfind.R................ 2565 tests [0;32mOK[0m 
  test-strfind.R................ 2565 tests [0;32mOK[0m 
  test-strfind.R................ 2565 tests [0;32mOK[0m ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  ----- PASSED      : test-strfind.R<515--538>
   call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  
  test-strfind.R................ 3405 tests [0;32mOK[0m 
  test-strfind.R................ 3405 tests [0;32mOK[0m 
  test-strfind.R................ 3405 tests [0;32mOK[0m 
  test-strfind.R................ 3405 tests [0;32mOK[0m 
  test-strfind.R................ 3405 tests [0;32mOK[0m 
  test-strfind.R................ 3406 tests [0;32mOK[0m 
  test-strfind.R................ 3407 tests [0;32mOK[0m 
  test-strfind.R................ 3407 tests [0;32mOK[0m [1] "abcdefghijklm" "nopqrstuvwxyz" "ABCDEFGHIJKLM" "NOPQRSTUVWXYZ"
  
  test-strfind.R................ 3407 tests [0;32mOK[0m 
  test-strfind.R................ 3407 tests [0;32mOK[0m 
  test-strfind.R................ 3407 tests [0;32mOK[0m 
  test-strfind.R................ 3408 tests [0;32mOK[0m 
  test-strfind.R................ 3409 tests [0;32mOK[0m 
  test-strfind.R................ 3409 tests [0;32mOK[0m 
  test-strfind.R................ 3409 tests [0;32mOK[0m 
  test-strfind.R................ 3410 tests [0;32mOK[0m 
  test-strfind.R................ 3410 tests [0;32mOK[0m 
  test-strfind.R................ 3410 tests [0;32mOK[0m 
  test-strfind.R................ 3410 tests [0;32mOK[0m 
  test-strfind.R................ 3411 tests [0;32mOK[0m 
  test-strfind.R................ 3411 tests [0;32mOK[0m 
  test-strfind.R................ 3411 tests [0;32mOK[0m 
  test-strfind.R................ 3412 tests [0;32mOK[0m 
  test-strfind.R................ 3413 tests [0;32mOK[0m 
  test-strfind.R................ 3413 tests [0;32mOK[0m 
  test-strfind.R................ 3413 tests [0;32mOK[0m 
  test-strfind.R................ 3414 tests [0;32mOK[0m 
  test-strfind.R................ 3415 tests [0;32mOK[0m 
  test-strfind.R................ 3416 tests [0;32mOK[0m 
  test-strfind.R................ 3417 tests [0;32mOK[0m 
  test-strfind.R................ 3418 tests [0;32mOK[0m 
  test-strfind.R................ 3419 tests [0;32mOK[0m 
  test-strfind.R................ 3420 tests [0;32mOK[0m 
  test-strfind.R................ 3421 tests [0;32mOK[0m 
  test-strfind.R................ 3422 tests [0;32mOK[0m 
  test-strfind.R................ 3423 tests [0;32mOK[0m [0;34m24.8s[0m
  
  test-stri_join_mat.R..........    0 tests    
  test-stri_join_mat.R..........    1 tests [0;32mOK[0m 
  test-stri_join_mat.R..........    2 tests [0;32mOK[0m 
  test-stri_join_mat.R..........    3 tests [0;32mOK[0m [0;36m3ms[0m
  
  test-stri_locate_ith.R........    0 tests    
  test-stri_locate_ith.R........    0 tests    
  test-stri_locate_ith.R........    0 tests    
  test-stri_locate_ith.R........    0 tests     [1] "0123456789" "0123456789" "0123456789" "0123456789" "0123456789"
   [6] "0123456789" "0123456789" "0123456789" "0123456789" "0123456789"
  
  test-stri_locate_ith.R........    0 tests    
  test-stri_locate_ith.R........    0 tests    
  test-stri_locate_ith.R........    0 tests    
  test-stri_locate_ith.R........    0 tests    
  test-stri_locate_ith.R........    0 tests    
  test-stri_locate_ith.R........    0 tests    
  test-stri_locate_ith.R........    1 tests [0;32mOK[0m 
  test-stri_locate_ith.R........    1 tests [0;32mOK[0m  [1] "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa"
   [6] "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa"
  
  test-stri_locate_ith.R........    1 tests [0;32mOK[0m 
  test-stri_locate_ith.R........    1 tests [0;32mOK[0m 
  test-stri_locate_ith.R........    1 tests [0;32mOK[0m 
  test-stri_locate_ith.R........    1 tests [0;32mOK[0m 
  test-stri_locate_ith.R........    1 tests [0;32mOK[0m 
  test-stri_locate_ith.R........    1 tests [0;32mOK[0m 
  test-stri_locate_ith.R........    2 tests [0;32mOK[0m 
  test-stri_locate_ith.R........    2 tests [0;32mOK[0m  [1] "ýýýýýýýýýý" "ýýýýýýýýýý" "ýýýýýýýýýý" "ýýýýýýýýýý" "ýýýýýýýýýý"
   [6] "ýýýýýýýýýý" "ýýýýýýýýýý" "ýýýýýýýýýý" "ýýýýýýýýýý" "ýýýýýýýýýý"
  
  test-stri_locate_ith.R........    2 tests [0;32mOK[0m 
  test-stri_locate_ith.R........    2 tests [0;32mOK[0m 
  test-stri_locate_ith.R........    2 tests [0;32mOK[0m 
  test-stri_locate_ith.R........    2 tests [0;32mOK[0m 
  test-stri_locate_ith.R........    2 tests [0;32mOK[0m 
  test-stri_locate_ith.R........    2 tests [0;32mOK[0m 
  test-stri_locate_ith.R........    3 tests [0;32mOK[0m 
  test-stri_locate_ith.R........    3 tests [0;32mOK[0m  [1] "a a a a a a a a a a" "a a a a a a a a a a" "a a a a a a a a a a"
   [4] "a a a a a a a a a a" "a a a a a a a a a a" "a a a a a a a a a a"
   [7] "a a a a a a a a a a" "a a a a a a a a a a" "a a a a a a a a a a"
  [10] "a a a a a a a a a a"
  
  test-stri_locate_ith.R........    3 tests [0;32mOK[0m 
  test-stri_locate_ith.R........    3 tests [0;32mOK[0m 
  test-stri_locate_ith.R........    3 tests [0;32mOK[0m 
  test-stri_locate_ith.R........    3 tests [0;32mOK[0m 
  test-stri_locate_ith.R........    3 tests [0;32mOK[0m 
  test-stri_locate_ith.R........    3 tests [0;32mOK[0m 
  test-stri_locate_ith.R........    4 tests [0;32mOK[0m 
  test-stri_locate_ith.R........    4 tests [0;32mOK[0m  [1] "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa"
   [6] "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa"
  
  test-stri_locate_ith.R........    4 tests [0;32mOK[0m 
  test-stri_locate_ith.R........    4 tests [0;32mOK[0m 
  test-stri_locate_ith.R........    4 tests [0;32mOK[0m 
  test-stri_locate_ith.R........    4 tests [0;32mOK[0m 
  test-stri_locate_ith.R........    4 tests [0;32mOK[0m 
  test-stri_locate_ith.R........    4 tests [0;32mOK[0m 
  test-stri_locate_ith.R........    5 tests [0;32mOK[0m 
  test-stri_locate_ith.R........    5 tests [0;32mOK[0m 
  test-stri_locate_ith.R........    5 tests [0;32mOK[0m 
  test-stri_locate_ith.R........    5 tests [0;32mOK[0m 
  test-stri_locate_ith.R........    5 tests [0;32mOK[0m 
  test-stri_locate_ith.R........    5 tests [0;32mOK[0m 
  test-stri_locate_ith.R........    5 tests [0;32mOK[0m 
  test-stri_locate_ith.R........    5 tests [0;32mOK[0m 
  test-stri_locate_ith.R........    5 tests [0;32mOK[0m 
  test-stri_locate_ith.R........    6 tests [0;32mOK[0m 
  test-stri_locate_ith.R........    6 tests [0;32mOK[0m 
  test-stri_locate_ith.R........    6 tests [0;32mOK[0m 
  test-stri_locate_ith.R........    6 tests [0;32mOK[0m iX =  1 ; iP =  1 ; iCI =  TRUE 
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = 1), 
   call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = -1), 
   call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = 1, merge = FALSE), stringi::stri_locate_first(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = -1, merge = FALSE), stringi::stri_locate_last(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, last"
  iX =  1 ; iP =  1 ; iCI =  FALSE 
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = 1), 
   call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = -1), 
   call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = 1, merge = FALSE), stringi::stri_locate_first(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = -1, merge = FALSE), stringi::stri_locate_last(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, last"
  iX =  1 ; iP =  2 ; iCI =  TRUE 
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = 1), 
   call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = -1), 
   call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = 1, merge = FALSE), stringi::stri_locate_first(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = -1, merge = FALSE), stringi::stri_locate_last(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, last"
  iX =  1 ; iP =  2 ; iCI =  FALSE 
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = 1), 
   call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = -1), 
   call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = 1, merge = FALSE), stringi::stri_locate_first(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = -1, merge = FALSE), stringi::stri_locate_last(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, last"
  iX =  1 ; iP =  3 ; iCI =  TRUE 
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = 1), 
   call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = -1), 
   call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = 1, merge = FALSE), stringi::stri_locate_first(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = -1, merge = FALSE), stringi::stri_locate_last(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, last"
  iX =  1 ; iP =  3 ; iCI =  FALSE 
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = 1), 
   call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = -1), 
   call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = 1, merge = FALSE), stringi::stri_locate_first(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = -1, merge = FALSE), stringi::stri_locate_last(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, last"
  iX =  1 ; iP =  4 ; iCI =  TRUE 
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = 1), 
   call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = -1), 
   call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = 1, merge = FALSE), stringi::stri_locate_first(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = -1, merge = FALSE), stringi::stri_locate_last(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, last"
  iX =  1 ; iP =  4 ; iCI =  FALSE 
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = 1), 
   call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = -1), 
   call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = 1, merge = FALSE), stringi::stri_locate_first(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = -1, merge = FALSE), stringi::stri_locate_last(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, last"
  iX =  1 ; iP =  5 ; iCI =  TRUE 
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = 1), 
   call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = -1), 
   call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = 1, merge = FALSE), stringi::stri_locate_first(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = -1, merge = FALSE), stringi::stri_locate_last(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, last"
  iX =  1 ; iP =  5 ; iCI =  FALSE 
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = 1), 
   call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = -1), 
   call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = 1, merge = FALSE), stringi::stri_locate_first(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = -1, merge = FALSE), stringi::stri_locate_last(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, last"
  iX =  2 ; iP =  1 ; iCI =  TRUE 
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = 1), 
   call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = -1), 
   call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = 1, merge = FALSE), stringi::stri_locate_first(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = -1, merge = FALSE), stringi::stri_locate_last(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, last"
  iX =  2 ; iP =  1 ; iCI =  FALSE 
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = 1), 
   call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = -1), 
   call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = 1, merge = FALSE), stringi::stri_locate_first(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = -1, merge = FALSE), stringi::stri_locate_last(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, last"
  iX =  2 ; iP =  2 ; iCI =  TRUE 
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = 1), 
   call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = -1), 
   call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = 1, merge = FALSE), stringi::stri_locate_first(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = -1, merge = FALSE), stringi::stri_locate_last(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, last"
  iX =  2 ; iP =  2 ; iCI =  FALSE 
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = 1), 
   call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = -1), 
   call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = 1, merge = FALSE), stringi::stri_locate_first(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = -1, merge = FALSE), stringi::stri_locate_last(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, last"
  iX =  2 ; iP =  3 ; iCI =  TRUE 
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = 1), 
   call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = -1), 
   call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = 1, merge = FALSE), stringi::stri_locate_first(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = -1, merge = FALSE), stringi::stri_locate_last(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, last"
  iX =  2 ; iP =  3 ; iCI =  FALSE 
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = 1), 
   call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = -1), 
   call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = 1, merge = FALSE), stringi::stri_locate_first(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = -1, merge = FALSE), stringi::stri_locate_last(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, last"
  iX =  2 ; iP =  4 ; iCI =  TRUE 
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = 1), 
   call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = -1), 
   call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = 1, merge = FALSE), stringi::stri_locate_first(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = -1, merge = FALSE), stringi::stri_locate_last(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, last"
  iX =  2 ; iP =  4 ; iCI =  FALSE 
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = 1), 
   call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = -1), 
   call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = 1, merge = FALSE), stringi::stri_locate_first(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = -1, merge = FALSE), stringi::stri_locate_last(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, last"
  iX =  2 ; iP =  5 ; iCI =  TRUE 
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = 1), 
   call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = -1), 
   call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = 1, merge = FALSE), stringi::stri_locate_first(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = -1, merge = FALSE), stringi::stri_locate_last(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, last"
  iX =  2 ; iP =  5 ; iCI =  FALSE 
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = 1), 
   call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = -1), 
   call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = 1, merge = FALSE), stringi::stri_locate_first(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = -1, merge = FALSE), stringi::stri_locate_last(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, last"
  iX =  3 ; iP =  1 ; iCI =  TRUE 
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = 1), 
   call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = -1), 
   call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = 1, merge = FALSE), stringi::stri_locate_first(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = -1, merge = FALSE), stringi::stri_locate_last(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, last"
  iX =  3 ; iP =  1 ; iCI =  FALSE 
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = 1), 
   call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = -1), 
   call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = 1, merge = FALSE), stringi::stri_locate_first(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = -1, merge = FALSE), stringi::stri_locate_last(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, last"
  iX =  3 ; iP =  2 ; iCI =  TRUE 
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_regex(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: regex, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = 1), 
   call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_coll(x[[iX]], pattern[[iP]], i = -1), 
   call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
  [1] "Done: coll, last"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = 1, merge = FALSE), stringi::stri_locate_first(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_charclass(x[[iX]], stringi::stri_c("[", 
   call| -->    pattern[[iP]], "]"), i = -1, merge = FALSE), stringi::stri_locate_last(x[[iX]], 
   call| -->    charclass = stringi::stri_c("[", pattern[[iP]], "]"))) 
  [1] "Done: charclass, last"
  iX =  3 ; iP =  2 ; iCI =  FALSE 
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = 1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_first(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, first"
  ----- PASSED      : test-stri_locate_ith.R<92--157>
   call| expect_equal(stri_locate_ith_fixed(x[[iX]], pattern[[iP]], i = -1, 
   call| -->    case_insensitive = iCI), stringi::stri_locate_last(x[[iX]], 
   call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
  [1] "Done: fixed, last"
  ----- PASSED      : test-stri_locate_ith