R Under development (unstable) (2024-02-16 r85931 ucrt) -- "Unsuffered Consequences"
Copyright (C) 2024 The R Foundation for Statistical Computing
Platform: x86_64-w64-mingw32/x64

R is free software and comes with ABSOLUTELY NO WARRANTY.
You are welcome to redistribute it under certain conditions.
Type 'license()' or 'licence()' for distribution details.

R is a collaborative project with many contributors.
Type 'contributors()' for more information and
'citation()' on how to cite R or R packages in publications.

Type 'demo()' for some demos, 'help()' for on-line help, or
'help.start()' for an HTML browser interface to help.
Type 'q()' to quit R.

> 
> 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 OK 
test-atomic_conversions.R.....    1 tests OK 
test-atomic_conversions.R.....    1 tests OK 
test-atomic_conversions.R.....    2 tests OK 
test-atomic_conversions.R.....    2 tests OK 
test-atomic_conversions.R.....    2 tests OK 
test-atomic_conversions.R.....    3 tests OK 
test-atomic_conversions.R.....    3 tests OK 
test-atomic_conversions.R.....    3 tests OK 
test-atomic_conversions.R.....    4 tests OK 
test-atomic_conversions.R.....    4 tests OK 
test-atomic_conversions.R.....    4 tests OK 
test-atomic_conversions.R.....    4 tests OK 
test-atomic_conversions.R.....    4 tests OK 
test-atomic_conversions.R.....    4 tests OK 
test-atomic_conversions.R.....    4 tests OK 
test-atomic_conversions.R.....    4 tests OK 
test-atomic_conversions.R.....    4 tests OK 
test-atomic_conversions.R.....    5 tests OK 
test-atomic_conversions.R.....    5 tests OK 
test-atomic_conversions.R.....    5 tests OK 
test-atomic_conversions.R.....    5 tests OK 
test-atomic_conversions.R.....    6 tests OK 
test-atomic_conversions.R.....    6 tests OK 
test-atomic_conversions.R.....    6 tests OK 
test-atomic_conversions.R.....    6 tests OK 
test-atomic_conversions.R.....    7 tests OK 
test-atomic_conversions.R.....    7 tests OK 
test-atomic_conversions.R.....    7 tests OK 
test-atomic_conversions.R.....    7 tests OK 
test-atomic_conversions.R.....    8 tests OK 
test-atomic_conversions.R.....    8 tests OK 
test-atomic_conversions.R.....    8 tests OK 
test-atomic_conversions.R.....    8 tests OK 
test-atomic_conversions.R.....    8 tests OK 
test-atomic_conversions.R.....    8 tests OK 
test-atomic_conversions.R.....    8 tests OK 
test-atomic_conversions.R.....    8 tests OK 
test-atomic_conversions.R.....    8 tests OK 
test-atomic_conversions.R.....    9 tests OK 
test-atomic_conversions.R.....    9 tests OK 
test-atomic_conversions.R.....    9 tests OK 
test-atomic_conversions.R.....    9 tests OK 
test-atomic_conversions.R.....    9 tests OK 
test-atomic_conversions.R.....    9 tests OK 
test-atomic_conversions.R.....    9 tests OK 
test-atomic_conversions.R.....    9 tests OK 
test-atomic_conversions.R.....    9 tests OK 
test-atomic_conversions.R.....   10 tests OK 
test-atomic_conversions.R.....   10 tests OK 
test-atomic_conversions.R.....   10 tests OK 
test-atomic_conversions.R.....   11 tests OK 
test-atomic_conversions.R.....   11 tests OK 
test-atomic_conversions.R.....   11 tests OK 
test-atomic_conversions.R.....   12 tests OK 
test-atomic_conversions.R.....   12 tests OK 
test-atomic_conversions.R.....   12 tests OK 
test-atomic_conversions.R.....   13 tests OK 
test-atomic_conversions.R.....   13 tests OK 
test-atomic_conversions.R.....   13 tests OK 
test-atomic_conversions.R.....   13 tests OK 
test-atomic_conversions.R.....   13 tests OK 
test-atomic_conversions.R.....   13 tests OK 
test-atomic_conversions.R.....   13 tests OK 
test-atomic_conversions.R.....   13 tests OK 
test-atomic_conversions.R.....   13 tests OK 
test-atomic_conversions.R.....   13 tests OK 
test-atomic_conversions.R.....   14 tests OK 
test-atomic_conversions.R.....   14 tests OK 
test-atomic_conversions.R.....   14 tests OK 
test-atomic_conversions.R.....   14 tests OK 
test-atomic_conversions.R.....   15 tests OK 
test-atomic_conversions.R.....   15 tests OK 
test-atomic_conversions.R.....   15 tests OK 
test-atomic_conversions.R.....   15 tests OK 
test-atomic_conversions.R.....   16 tests OK 
test-atomic_conversions.R.....   16 tests OK 
test-atomic_conversions.R.....   16 tests OK 
test-atomic_conversions.R.....   16 tests OK 
test-atomic_conversions.R.....   17 tests OK 
test-atomic_conversions.R.....   17 tests OK 
test-atomic_conversions.R.....   17 tests OK 
test-atomic_conversions.R.....   17 tests OK 
test-atomic_conversions.R.....   17 tests OK 
test-atomic_conversions.R.....   17 tests OK 
test-atomic_conversions.R.....   17 tests OK 
test-atomic_conversions.R.....   17 tests OK 
test-atomic_conversions.R.....   17 tests OK 
test-atomic_conversions.R.....   18 tests OK 92ms

test-constants.R..............    0 tests    
test-constants.R..............    1 tests OK 
test-constants.R..............    1 tests OK 
test-constants.R..............    2 tests OK 
test-constants.R..............    2 tests OK 
test-constants.R..............    3 tests OK 
test-constants.R..............    3 tests OK 
test-constants.R..............    4 tests OK 
test-constants.R..............    4 tests OK 
test-constants.R..............    5 tests OK 
test-constants.R..............    5 tests OK 
test-constants.R..............    6 tests OK 
test-constants.R..............    6 tests OK 
test-constants.R..............    7 tests OK 
test-constants.R..............    7 tests OK 
test-constants.R..............    8 tests OK 
test-constants.R..............    8 tests OK 
test-constants.R..............    9 tests OK 
test-constants.R..............    9 tests OK 
test-constants.R..............   10 tests OK 
test-constants.R..............   10 tests OK 
test-constants.R..............   11 tests OK 
test-constants.R..............   11 tests OK 
test-constants.R..............   12 tests OK 
test-constants.R..............   12 tests OK 
test-constants.R..............   13 tests OK 
test-constants.R..............   13 tests OK 
test-constants.R..............   14 tests OK 
test-constants.R..............   14 tests OK 
test-constants.R..............   15 tests OK 
test-constants.R..............   15 tests OK 
test-constants.R..............   16 tests OK 
test-constants.R..............   16 tests OK 
test-constants.R..............   17 tests OK 
test-constants.R..............   17 tests OK 
test-constants.R..............   18 tests OK 
test-constants.R..............   18 tests OK 
test-constants.R..............   18 tests OK 
test-constants.R..............   19 tests OK 
test-constants.R..............   20 tests OK 
test-constants.R..............   21 tests OK 
test-constants.R..............   22 tests OK 7ms

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 OK 
test-decimal-between.R........    2 tests OK 
test-decimal-between.R........    3 tests OK 
test-decimal-between.R........    4 tests OK 
test-decimal-between.R........    5 tests OK 
test-decimal-between.R........    6 tests OK 
test-decimal-between.R........    7 tests OK 
test-decimal-between.R........    8 tests OK 
test-decimal-between.R........    9 tests OK 
test-decimal-between.R........   10 tests OK 
test-decimal-between.R........   11 tests OK 
test-decimal-between.R........   12 tests OK 
test-decimal-between.R........   13 tests OK 
test-decimal-between.R........   13 tests OK 
test-decimal-between.R........   13 tests OK 
test-decimal-between.R........   14 tests OK 
test-decimal-between.R........   14 tests OK 
test-decimal-between.R........   14 tests OK 
test-decimal-between.R........   14 tests OK 
test-decimal-between.R........   14 tests OK 
test-decimal-between.R........   14 tests OK 
test-decimal-between.R........   15 tests OK 
test-decimal-between.R........   16 tests OK 
test-decimal-between.R........   17 tests OK 
test-decimal-between.R........   18 tests OK 
test-decimal-between.R........   19 tests OK 11ms

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 OK 
test-decimal-eq.R.............    2 tests OK 
test-decimal-eq.R.............    3 tests OK 
test-decimal-eq.R.............    4 tests OK 
test-decimal-eq.R.............    5 tests OK 
test-decimal-eq.R.............    6 tests OK 
test-decimal-eq.R.............    7 tests OK 
test-decimal-eq.R.............    8 tests OK 
test-decimal-eq.R.............    9 tests OK 
test-decimal-eq.R.............    9 tests OK 
test-decimal-eq.R.............   10 tests OK 
test-decimal-eq.R.............   11 tests OK 
test-decimal-eq.R.............   12 tests OK 
test-decimal-eq.R.............   13 tests OK 
test-decimal-eq.R.............   14 tests OK 
test-decimal-eq.R.............   15 tests OK 
test-decimal-eq.R.............   15 tests OK 
test-decimal-eq.R.............   15 tests OK 
test-decimal-eq.R.............   15 tests OK 
test-decimal-eq.R.............   16 tests OK 
test-decimal-eq.R.............   17 tests OK 
test-decimal-eq.R.............   18 tests OK 
test-decimal-eq.R.............   19 tests OK 
test-decimal-eq.R.............   20 tests OK 
test-decimal-eq.R.............   21 tests OK 
test-decimal-eq.R.............   22 tests OK 
test-decimal-eq.R.............   23 tests OK 
test-decimal-eq.R.............   24 tests OK 
test-decimal-eq.R.............   25 tests OK 
test-decimal-eq.R.............   26 tests OK 
test-decimal-eq.R.............   27 tests OK 
test-decimal-eq.R.............   28 tests OK 
test-decimal-eq.R.............   29 tests OK 
test-decimal-eq.R.............   30 tests OK 
test-decimal-eq.R.............   31 tests OK 
test-decimal-eq.R.............   32 tests OK 
test-decimal-eq.R.............   33 tests OK 
test-decimal-eq.R.............   34 tests OK 
test-decimal-eq.R.............   35 tests OK 
test-decimal-eq.R.............   36 tests OK 
test-decimal-eq.R.............   37 tests OK 
test-decimal-eq.R.............   38 tests OK 
test-decimal-eq.R.............   39 tests OK 
test-decimal-eq.R.............   40 tests OK 
test-decimal-eq.R.............   41 tests OK 10ms

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 OK 
test-decimal-is_wholenumber.R.    2 tests OK 
test-decimal-is_wholenumber.R.    3 tests OK 
test-decimal-is_wholenumber.R.    4 tests OK 
test-decimal-is_wholenumber.R.    5 tests OK 
test-decimal-is_wholenumber.R.    6 tests OK 
test-decimal-is_wholenumber.R.    7 tests OK 
test-decimal-is_wholenumber.R.    8 tests OK 
test-decimal-is_wholenumber.R.    9 tests OK 
test-decimal-is_wholenumber.R.   10 tests OK 
test-decimal-is_wholenumber.R.   10 tests OK 
test-decimal-is_wholenumber.R.   11 tests OK 
test-decimal-is_wholenumber.R.   12 tests OK 
test-decimal-is_wholenumber.R.   13 tests OK 
test-decimal-is_wholenumber.R.   14 tests OK 
test-decimal-is_wholenumber.R.   15 tests OK 
test-decimal-is_wholenumber.R.   16 tests OK 
test-decimal-is_wholenumber.R.   17 tests OK 
test-decimal-is_wholenumber.R.   18 tests OK 
test-decimal-is_wholenumber.R.   19 tests OK 6ms

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 OK 
test-dry.R....................    2 tests OK 
test-dry.R....................    3 tests OK 
test-dry.R....................    4 tests OK 
test-dry.R....................    5 tests OK 
test-dry.R....................    5 tests OK 
test-dry.R....................    6 tests OK 
test-dry.R....................    6 tests OK 
test-dry.R....................    6 tests OK 
test-dry.R....................    6 tests OK 
test-dry.R....................    6 tests OK 
test-dry.R....................    6 tests OK 
test-dry.R....................    6 tests OK 
test-dry.R....................    6 tests OK 
test-dry.R....................    6 tests OK 
test-dry.R....................    6 tests OK 
test-dry.R....................    7 tests OK 
test-dry.R....................    8 tests OK 
test-dry.R....................    9 tests OK 
test-dry.R....................   10 tests OK 
test-dry.R....................   11 tests OK 
test-dry.R....................   12 tests OK 
test-dry.R....................   13 tests OK 
test-dry.R....................   14 tests OK 
test-dry.R....................   15 tests OK 
test-dry.R....................   15 tests OK 
test-dry.R....................   16 tests OK 
test-dry.R....................   17 tests OK 
test-dry.R....................   18 tests OK 
test-dry.R....................   19 tests OK 
test-dry.R....................   19 tests OK 
test-dry.R....................   19 tests OK 
test-dry.R....................   20 tests OK 
test-dry.R....................   20 tests OK 
test-dry.R....................   20 tests OK 
test-dry.R....................   20 tests OK 
test-dry.R....................   20 tests OK 
test-dry.R....................   21 tests OK 
test-dry.R....................   21 tests OK 
test-dry.R....................   21 tests OK 
test-dry.R....................   21 tests OK 
test-dry.R....................   21 tests OK 
test-dry.R....................   22 tests OK 11ms

test-import_LL.R..............    0 tests    
test-import_LL.R..............    1 tests OK 
test-import_LL.R..............    1 tests OK 
test-import_LL.R..............    1 tests OK 
test-import_LL.R..............    2 tests OK 
test-import_LL.R..............    2 tests OK 
test-import_LL.R..............    3 tests OK 
test-import_LL.R..............    3 tests OK 
test-import_LL.R..............    4 tests OK 
test-import_LL.R..............    4 tests OK 
test-import_LL.R..............    5 tests OK 
test-import_LL.R..............    5 tests OK 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 OK 
test-import_LL.R..............    6 tests OK 
test-import_LL.R..............    7 tests OK 
test-import_LL.R..............    8 tests OK 
test-import_LL.R..............    9 tests OK 
test-import_LL.R..............   10 tests OK 
test-import_LL.R..............   11 tests OK 
test-import_LL.R..............   12 tests OK 
test-import_LL.R..............   13 tests OK 
test-import_LL.R..............   14 tests OK 
test-import_LL.R..............   15 tests OK 
test-import_LL.R..............   16 tests OK 
test-import_LL.R..............   17 tests OK 
test-import_LL.R..............   18 tests OK 
test-import_LL.R..............   19 tests OK 
test-import_LL.R..............   20 tests OK 0.2s

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 OK 
test-import_as.R..............    1 tests OK 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 OK 
test-import_as.R..............    3 tests OK 
test-import_as.R..............    4 tests OK 
test-import_as.R..............    5 tests OK 
test-import_as.R..............    6 tests OK 
test-import_as.R..............    7 tests OK 
test-import_as.R..............    8 tests OK 
test-import_as.R..............    9 tests OK 
test-import_as.R..............   10 tests OK 
test-import_as.R..............   11 tests OK 
test-import_as.R..............   12 tests OK 
test-import_as.R..............   13 tests OK 
test-import_as.R..............   14 tests OK 
test-import_as.R..............   15 tests OK 
test-import_as.R..............   16 tests OK 
test-import_as.R..............   17 tests OK 
test-import_as.R..............   18 tests OK 
test-import_as.R..............   19 tests OK 
test-import_as.R..............   20 tests OK 
test-import_as.R..............   21 tests OK 
test-import_as.R..............   22 tests OK 
test-import_as.R..............   23 tests OK 
test-import_as.R..............   23 tests OK 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 OK 88ms

test-import_data.R............    0 tests    
test-import_data.R............    1 tests OK 
test-import_data.R............    2 tests OK 
test-import_data.R............    3 tests OK 
test-import_data.R............    4 tests OK 8ms

test-import_general.R.........    0 tests    
test-import_general.R.........    0 tests    
test-import_general.R.........    0 tests    
test-import_general.R.........    1 tests OK 
test-import_general.R.........    2 tests OK 
test-import_general.R.........    3 tests OK 
test-import_general.R.........    4 tests OK 
test-import_general.R.........    5 tests OK 
test-import_general.R.........    6 tests OK 
test-import_general.R.........    6 tests OK 
test-import_general.R.........    6 tests OK ----- 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 OK 
test-import_general.R.........   17 tests OK 
test-import_general.R.........   17 tests OK 
test-import_general.R.........   17 tests OK 
test-import_general.R.........   17 tests OK ----- 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 OK 
test-import_general.R.........   77 tests OK 
test-import_general.R.........   77 tests OK 
test-import_general.R.........   77 tests OK ----- 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 OK 
test-import_general.R.........   96 tests OK 
test-import_general.R.........   97 tests OK 
test-import_general.R.........   98 tests OK 
test-import_general.R.........   99 tests OK 
test-import_general.R.........  100 tests OK 
test-import_general.R.........  101 tests OK 
test-import_general.R.........  102 tests OK 0.4s

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 OK 
test-import_inops-alias.R.....    1 tests OK 
test-import_inops-alias.R.....    1 tests OK 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 OK 
test-import_inops-alias.R.....    2 tests OK 
test-import_inops-alias.R.....    2 tests OK 
test-import_inops-alias.R.....    2 tests OK 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 OK 
test-import_inops-alias.R.....    3 tests OK 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 OK 
test-import_inops-alias.R.....    4 tests OK 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 OK 
test-import_inops-alias.R.....    5 tests OK 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 OK 
test-import_inops-alias.R.....    6 tests OK 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 OK 
test-import_inops-alias.R.....    7 tests OK 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 OK 
test-import_inops-alias.R.....    8 tests OK 
test-import_inops-alias.R.....    9 tests OK 
test-import_inops-alias.R.....    9 tests OK 
test-import_inops-alias.R.....   10 tests OK 
test-import_inops-alias.R.....   10 tests OK 
test-import_inops-alias.R.....   11 tests OK 0.2s

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 OK 
test-import_inops-pkgs.R......    1 tests OK 
test-import_inops-pkgs.R......    1 tests OK Checking for conflicting infix operators in the current environment...
Placing infix operators in current environment...
Done

test-import_inops-pkgs.R......    2 tests OK 
test-import_inops-pkgs.R......    2 tests OK 
test-import_inops-pkgs.R......    2 tests OK 
test-import_inops-pkgs.R......    2 tests OK Checking for conflicting infix operators in the current environment...
Placing infix operators in current environment...
Done

test-import_inops-pkgs.R......    3 tests OK 
test-import_inops-pkgs.R......    3 tests OK 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 OK 
test-import_inops-pkgs.R......    4 tests OK Checking for conflicting infix operators in the current environment...
Placing infix operators in current environment...
Done

test-import_inops-pkgs.R......    5 tests OK 
test-import_inops-pkgs.R......    5 tests OK 
test-import_inops-pkgs.R......    6 tests OK 
test-import_inops-pkgs.R......    7 tests OK 
test-import_inops-pkgs.R......    8 tests OK 
test-import_inops-pkgs.R......    9 tests OK 
test-import_inops-pkgs.R......   10 tests OK 
test-import_inops-pkgs.R......   11 tests OK 
test-import_inops-pkgs.R......   12 tests OK 
test-import_inops-pkgs.R......   13 tests OK 
test-import_inops-pkgs.R......   14 tests OK 
test-import_inops-pkgs.R......   15 tests OK 
test-import_inops-pkgs.R......   15 tests OK 
test-import_inops-pkgs.R......   16 tests OK 99ms

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 OK 
test-import_inops.control.R...    1 tests OK 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 OK 
test-import_inops.control.R...    2 tests OK 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 OK 
test-import_inops.control.R...    3 tests OK 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 OK 
test-import_inops.control.R...    4 tests OK 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 OK 
test-import_inops.control.R...    5 tests OK 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 OK 
test-import_inops.control.R...    6 tests OK 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 OK 
test-import_inops.control.R...    7 tests OK 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 OK 
test-import_inops.control.R...    8 tests OK 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 OK 
test-import_inops.control.R...    9 tests OK 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 OK 
test-import_inops.control.R...   10 tests OK 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 OK 
test-import_inops.control.R...   11 tests OK 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 OK 
test-import_inops.control.R...   12 tests OK 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 OK 
test-import_inops.control.R...   13 tests OK 
test-import_inops.control.R...   14 tests OK 
test-import_inops.control.R...   14 tests OK 
test-import_inops.control.R...   15 tests OK 
test-import_inops.control.R...   15 tests OK 
test-import_inops.control.R...   16 tests OK 
test-import_inops.control.R...   16 tests OK 
test-import_inops.control.R...   17 tests OK 
test-import_inops.control.R...   17 tests OK 
test-import_inops.control.R...   18 tests OK 
test-import_inops.control.R...   18 tests OK 
test-import_inops.control.R...   19 tests OK 
test-import_inops.control.R...   19 tests OK 
test-import_inops.control.R...   20 tests OK 
test-import_inops.control.R...   20 tests OK 
test-import_inops.control.R...   21 tests OK 
test-import_inops.control.R...   21 tests OK 
test-import_inops.control.R...   22 tests OK 
test-import_inops.control.R...   22 tests OK 
test-import_inops.control.R...   23 tests OK 
test-import_inops.control.R...   23 tests OK 
test-import_inops.control.R...   24 tests OK 
test-import_inops.control.R...   24 tests OK 
test-import_inops.control.R...   25 tests OK 
test-import_inops.control.R...   25 tests OK 
test-import_inops.control.R...   26 tests OK 
test-import_inops.control.R...   26 tests OK 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 OK 
test-import_inops.control.R...   27 tests OK 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 OK 
test-import_inops.control.R...   28 tests OK 
test-import_inops.control.R...   29 tests OK 
test-import_inops.control.R...   29 tests OK 
test-import_inops.control.R...   30 tests OK 0.4s

test-import_int.R.............    1 tests OK 
test-import_int.R.............    2 tests OK 
test-import_int.R.............    3 tests OK 
test-import_int.R.............    4 tests OK 
test-import_int.R.............    5 tests OK 
test-import_int.R.............    6 tests OK 
test-import_int.R.............    7 tests OK 
test-import_int.R.............    8 tests OK 
test-import_int.R.............    9 tests OK 
test-import_int.R.............   10 tests OK 
test-import_int.R.............   11 tests OK 
test-import_int.R.............   12 tests OK 28ms

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 OK 
test-import_lock.R............    1 tests OK Importing packages and registering methods...

test-import_lock.R............    2 tests OK 
test-import_lock.R............    2 tests OK 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 OK 
test-import_lock.R............    3 tests OK 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 OK 
test-import_lock.R............    4 tests OK 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 OK 
test-import_lock.R............    5 tests OK 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 OK 
test-import_lock.R............    6 tests OK 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 OK 
test-import_lock.R............    7 tests OK 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 OK 
test-import_lock.R............    8 tests OK 
test-import_lock.R............    8 tests OK 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 OK 
test-import_lock.R............    9 tests OK 
test-import_lock.R............   10 tests OK 0.3s

test-internal.R...............    1 tests OK 
test-internal.R...............    2 tests OK 
test-internal.R...............    3 tests OK 
test-internal.R...............    4 tests OK 
test-internal.R...............    5 tests OK 5ms

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 OK 
test-logic_ops.R..............    1 tests OK 
test-logic_ops.R..............    1 tests OK 
test-logic_ops.R..............    1 tests OK 
test-logic_ops.R..............    1 tests OK 
test-logic_ops.R..............    2 tests OK 
test-logic_ops.R..............    2 tests OK 
test-logic_ops.R..............    2 tests OK 
test-logic_ops.R..............    2 tests OK 
test-logic_ops.R..............    2 tests OK 
test-logic_ops.R..............    2 tests OK 
test-logic_ops.R..............    3 tests OK 
test-logic_ops.R..............    3 tests OK 
test-logic_ops.R..............    3 tests OK 
test-logic_ops.R..............    3 tests OK 
test-logic_ops.R..............    4 tests OK 
test-logic_ops.R..............    5 tests OK 
test-logic_ops.R..............    6 tests OK 
test-logic_ops.R..............    6 tests OK 
test-logic_ops.R..............    6 tests OK 
test-logic_ops.R..............    7 tests OK 
test-logic_ops.R..............    8 tests OK 
test-logic_ops.R..............    9 tests OK 
test-logic_ops.R..............   10 tests OK 
test-logic_ops.R..............   11 tests OK 
test-logic_ops.R..............   12 tests OK 
test-logic_ops.R..............   13 tests OK 
test-logic_ops.R..............   14 tests OK 
test-logic_ops.R..............   15 tests OK 
test-logic_ops.R..............   15 tests OK 
test-logic_ops.R..............   15 tests OK 
test-logic_ops.R..............   16 tests OK 
test-logic_ops.R..............   17 tests OK 
test-logic_ops.R..............   18 tests OK 
test-logic_ops.R..............   19 tests OK 
test-logic_ops.R..............   20 tests OK 
test-logic_ops.R..............   21 tests OK 
test-logic_ops.R..............   22 tests OK 
test-logic_ops.R..............   23 tests OK 
test-logic_ops.R..............   24 tests OK 
test-logic_ops.R..............   25 tests OK 24ms

test-matrix_ops.R.............    0 tests    
test-matrix_ops.R.............    0 tests    
test-matrix_ops.R.............    0 tests    
test-matrix_ops.R.............    1 tests OK 
test-matrix_ops.R.............    2 tests OK 
test-matrix_ops.R.............    2 tests OK 
test-matrix_ops.R.............    2 tests OK 
test-matrix_ops.R.............    3 tests OK 
test-matrix_ops.R.............    4 tests OK 5ms

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 OK 
test-pkgs.R...................    1 tests OK 
test-pkgs.R...................    1 tests OK 
test-pkgs.R...................    2 tests OK 
test-pkgs.R...................    2 tests OK 
test-pkgs.R...................    2 tests OK 
test-pkgs.R...................    3 tests OK 
test-pkgs.R...................    4 tests OK 
test-pkgs.R...................    5 tests OK 
test-pkgs.R...................    6 tests OK 
test-pkgs.R...................    7 tests OK 57ms

test-pversion.R...............    1 tests OK 
test-pversion.R...............    2 tests OK 
test-pversion.R...............    3 tests OK 11ms

test-report_inops.R...........    0 tests    
test-report_inops.R...........    1 tests OK 
test-report_inops.R...........    1 tests OK 
test-report_inops.R...........    2 tests OK 
test-report_inops.R...........    3 tests OK 
test-report_inops.R...........    4 tests OK 
test-report_inops.R...........    5 tests OK 
test-report_inops.R...........    5 tests OK 
test-report_inops.R...........    6 tests OK 
test-report_inops.R...........    7 tests OK 
test-report_inops.R...........    8 tests OK 
test-report_inops.R...........    9 tests OK 
test-report_inops.R...........    9 tests OK 
test-report_inops.R...........   10 tests OK 
test-report_inops.R...........   11 tests OK 
test-report_inops.R...........   12 tests OK 
test-report_inops.R...........   12 tests OK 
test-report_inops.R...........   13 tests OK 
test-report_inops.R...........   13 tests OK 
test-report_inops.R...........   14 tests OK 
test-report_inops.R...........   14 tests OK 
test-report_inops.R...........   15 tests OK 
test-report_inops.R...........   15 tests OK 
test-report_inops.R...........   15 tests OK 
test-report_inops.R...........   16 tests OK 0.3s

test-s_pattern.R..............    0 tests    
test-s_pattern.R..............    1 tests OK 
test-s_pattern.R..............    1 tests OK 
test-s_pattern.R..............    2 tests OK 
test-s_pattern.R..............    2 tests OK 
test-s_pattern.R..............    3 tests OK 
test-s_pattern.R..............    3 tests OK 
test-s_pattern.R..............    4 tests OK 
test-s_pattern.R..............    4 tests OK 
test-s_pattern.R..............    5 tests OK 
test-s_pattern.R..............    5 tests OK 
test-s_pattern.R..............    6 tests OK 
test-s_pattern.R..............    6 tests OK 
test-s_pattern.R..............    7 tests OK 
test-s_pattern.R..............    7 tests OK 
test-s_pattern.R..............    8 tests OK 5ms

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 OK 
test-source_selection.R.......    1 tests OK 
test-source_selection.R.......    1 tests OK Sourcing script ... 

Done

test-source_selection.R.......    2 tests OK 
test-source_selection.R.......    2 tests OK Sourcing script ... 

Done

test-source_selection.R.......    3 tests OK 
test-source_selection.R.......    3 tests OK Sourcing script ... 

Done

test-source_selection.R.......    4 tests OK 
test-source_selection.R.......    4 tests OK Sourcing script ... 

Done

test-source_selection.R.......    5 tests OK 
test-source_selection.R.......    5 tests OK Sourcing script ... 

Done

test-source_selection.R.......    6 tests OK 
test-source_selection.R.......    6 tests OK Sourcing script ... 

Done

test-source_selection.R.......    7 tests OK 
test-source_selection.R.......    7 tests OK Sourcing script ... 

Done

test-source_selection.R.......    8 tests OK 
test-source_selection.R.......    8 tests OK Sourcing script ... 

Done

test-source_selection.R.......    9 tests OK 
test-source_selection.R.......    9 tests OK Sourcing script ... 

Done

test-source_selection.R.......    9 tests OK 
test-source_selection.R.......   10 tests OK 
test-source_selection.R.......   11 tests OK 
test-source_selection.R.......   12 tests OK 
test-source_selection.R.......   13 tests OK Sourcing script ... 


test-source_selection.R.......   14 tests OK 
test-source_selection.R.......   15 tests OK 
test-source_selection.R.......   16 tests OK 
test-source_selection.R.......   17 tests OK 
test-source_selection.R.......   18 tests OK 
test-source_selection.R.......   19 tests OK Sourcing script ... 


test-source_selection.R.......   20 tests OK 
test-source_selection.R.......   21 tests OK 
test-source_selection.R.......   22 tests OK 12ms

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 OK 
test-str_arithmetic.R.........    2 tests OK 
test-str_arithmetic.R.........    3 tests OK 
test-str_arithmetic.R.........    3 tests OK 
test-str_arithmetic.R.........    3 tests OK 
test-str_arithmetic.R.........    3 tests OK 
test-str_arithmetic.R.........    3 tests OK 
test-str_arithmetic.R.........    4 tests OK 
test-str_arithmetic.R.........    5 tests OK 
test-str_arithmetic.R.........    6 tests OK 
test-str_arithmetic.R.........    6 tests OK 
test-str_arithmetic.R.........    6 tests OK 
test-str_arithmetic.R.........    7 tests OK 
test-str_arithmetic.R.........    8 tests OK 
test-str_arithmetic.R.........    9 tests OK 
test-str_arithmetic.R.........    9 tests OK 
test-str_arithmetic.R.........    9 tests OK 
test-str_arithmetic.R.........   10 tests OK 
test-str_arithmetic.R.........   11 tests OK 
test-str_arithmetic.R.........   12 tests OK 
test-str_arithmetic.R.........   13 tests OK 
test-str_arithmetic.R.........   14 tests OK 
test-str_arithmetic.R.........   15 tests OK 
test-str_arithmetic.R.........   15 tests OK 
test-str_arithmetic.R.........   15 tests OK 
test-str_arithmetic.R.........   15 tests OK 
test-str_arithmetic.R.........   15 tests OK 
test-str_arithmetic.R.........   15 tests OK 
test-str_arithmetic.R.........   15 tests OK 
test-str_arithmetic.R.........   15 tests OK 
test-str_arithmetic.R.........   16 tests OK 
test-str_arithmetic.R.........   17 tests OK 
test-str_arithmetic.R.........   18 tests OK 
test-str_arithmetic.R.........   18 tests OK 
test-str_arithmetic.R.........   18 tests OK 
test-str_arithmetic.R.........   19 tests OK 
test-str_arithmetic.R.........   20 tests OK 
test-str_arithmetic.R.........   21 tests OK 
test-str_arithmetic.R.........   22 tests OK 
test-str_arithmetic.R.........   23 tests OK 
test-str_arithmetic.R.........   24 tests OK 
test-str_arithmetic.R.........   24 tests OK 
test-str_arithmetic.R.........   24 tests OK 
test-str_arithmetic.R.........   25 tests OK 
test-str_arithmetic.R.........   26 tests OK 
test-str_arithmetic.R.........   27 tests OK 
test-str_arithmetic.R.........   27 tests OK [1] "abcdefghijklm" "nopqrstuvwxyz"

test-str_arithmetic.R.........   27 tests OK 
test-str_arithmetic.R.........   27 tests OK 
test-str_arithmetic.R.........   27 tests OK 
test-str_arithmetic.R.........   27 tests OK 
test-str_arithmetic.R.........   27 tests OK 
test-str_arithmetic.R.........   28 tests OK 
test-str_arithmetic.R.........   29 tests OK 
test-str_arithmetic.R.........   30 tests OK 
test-str_arithmetic.R.........   31 tests OK 
test-str_arithmetic.R.........   32 tests OK 
test-str_arithmetic.R.........   33 tests OK 
test-str_arithmetic.R.........   34 tests OK 
test-str_arithmetic.R.........   35 tests OK 
test-str_arithmetic.R.........   35 tests OK 
test-str_arithmetic.R.........   36 tests OK 
test-str_arithmetic.R.........   37 tests OK 
test-str_arithmetic.R.........   38 tests OK 
test-str_arithmetic.R.........   39 tests OK 
test-str_arithmetic.R.........   40 tests OK 
test-str_arithmetic.R.........   41 tests OK 
test-str_arithmetic.R.........   42 tests OK 
test-str_arithmetic.R.........   43 tests OK 30ms

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 OK 
test-str_search.R.............  336 tests OK 
test-str_search.R.............  337 tests OK 
test-str_search.R.............  338 tests OK 
test-str_search.R.............  339 tests OK 
test-str_search.R.............  340 tests OK 
test-str_search.R.............  341 tests OK 
test-str_search.R.............  342 tests OK 
test-str_search.R.............  343 tests OK 
test-str_search.R.............  344 tests OK 
test-str_search.R.............  345 tests OK 
test-str_search.R.............  346 tests OK 
test-str_search.R.............  346 tests OK 
test-str_search.R.............  346 tests OK 
test-str_search.R.............  347 tests OK 
test-str_search.R.............  348 tests OK 
test-str_search.R.............  349 tests OK 
test-str_search.R.............  350 tests OK 
test-str_search.R.............  351 tests OK 
test-str_search.R.............  352 tests OK 
test-str_search.R.............  352 tests OK 
test-str_search.R.............  352 tests OK 
test-str_search.R.............  353 tests OK 
test-str_search.R.............  354 tests OK 
test-str_search.R.............  355 tests OK 
test-str_search.R.............  356 tests OK 
test-str_search.R.............  356 tests OK 
test-str_search.R.............  356 tests OK 
test-str_search.R.............  356 tests OK 
test-str_search.R.............  356 tests OK 
test-str_search.R.............  356 tests OK 
test-str_search.R.............  356 tests OK 
test-str_search.R.............  356 tests OK 
test-str_search.R.............  357 tests OK 
test-str_search.R.............  358 tests OK 
test-str_search.R.............  358 tests OK 
test-str_search.R.............  358 tests OK 
test-str_search.R.............  359 tests OK 
test-str_search.R.............  360 tests OK 
test-str_search.R.............  361 tests OK 
test-str_search.R.............  362 tests OK 
test-str_search.R.............  362 tests OK 
test-str_search.R.............  362 tests OK 
test-str_search.R.............  363 tests OK 
test-str_search.R.............  364 tests OK 
test-str_search.R.............  365 tests OK 
test-str_search.R.............  366 tests OK 4.2s

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 OK 
test-str_search_at.R..........  672 tests OK 
test-str_search_at.R..........  672 tests OK 
test-str_search_at.R..........  673 tests OK 
test-str_search_at.R..........  673 tests OK 
test-str_search_at.R..........  674 tests OK 
test-str_search_at.R..........  674 tests OK 
test-str_search_at.R..........  675 tests OK 
test-str_search_at.R..........  675 tests OK 
test-str_search_at.R..........  676 tests OK 
test-str_search_at.R..........  677 tests OK 
test-str_search_at.R..........  678 tests OK 
test-str_search_at.R..........  679 tests OK 
test-str_search_at.R..........  680 tests OK 8.0s

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 OK 
test-str_subset_ops.R.........    1 tests OK 
test-str_subset_ops.R.........    1 tests OK 
test-str_subset_ops.R.........    1 tests OK 
test-str_subset_ops.R.........    1 tests OK 
test-str_subset_ops.R.........    2 tests OK 
test-str_subset_ops.R.........    3 tests OK 
test-str_subset_ops.R.........    3 tests OK 
test-str_subset_ops.R.........    3 tests OK 
test-str_subset_ops.R.........    3 tests OK 
test-str_subset_ops.R.........    4 tests OK 
test-str_subset_ops.R.........    4 tests OK [1] "abcdefghijklm" "nopqrstuvwxyz" "abcdefghijklm" "nopqrstuvwxyz"

test-str_subset_ops.R.........    4 tests OK 
test-str_subset_ops.R.........    4 tests OK 
test-str_subset_ops.R.........    5 tests OK 
test-str_subset_ops.R.........    6 tests OK 
test-str_subset_ops.R.........    7 tests OK 
test-str_subset_ops.R.........    8 tests OK 
test-str_subset_ops.R.........    9 tests OK 
test-str_subset_ops.R.........   10 tests OK 
test-str_subset_ops.R.........   11 tests OK 
test-str_subset_ops.R.........   12 tests OK 
test-str_subset_ops.R.........   12 tests OK 
test-str_subset_ops.R.........   13 tests OK 
test-str_subset_ops.R.........   14 tests OK 8ms

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 OK 
test-strcut.R.................    1 tests OK  [1] "12345678910" "12345678910" "12345678910" "12345678910" "12345678910"
 [6] "12345678910" "12345678910" "12345678910" "12345678910" "12345678910"

test-strcut.R.................    1 tests OK 
test-strcut.R.................    1 tests OK 
test-strcut.R.................    1 tests OK 
test-strcut.R.................    2 tests OK 
test-strcut.R.................    2 tests OK 
test-strcut.R.................    2 tests OK 
test-strcut.R.................    2 tests OK 
test-strcut.R.................    3 tests OK 
test-strcut.R.................    3 tests OK 
test-strcut.R.................    3 tests OK 
test-strcut.R.................    3 tests OK 
test-strcut.R.................    4 tests OK 
test-strcut.R.................    4 tests OK 
test-strcut.R.................    4 tests OK 
test-strcut.R.................    4 tests OK 
test-strcut.R.................    5 tests OK 
test-strcut.R.................    5 tests OK 
test-strcut.R.................    5 tests OK 
test-strcut.R.................    5 tests OK 
test-strcut.R.................    6 tests OK 
test-strcut.R.................    6 tests OK 
test-strcut.R.................    6 tests OK 
test-strcut.R.................    7 tests OK 
test-strcut.R.................    7 tests OK 
test-strcut.R.................    7 tests OK 
test-strcut.R.................    8 tests OK 
test-strcut.R.................    8 tests OK 
test-strcut.R.................    8 tests OK 
test-strcut.R.................    9 tests OK 
test-strcut.R.................    9 tests OK 
test-strcut.R.................   10 tests OK 
test-strcut.R.................   11 tests OK 
test-strcut.R.................   12 tests OK 
test-strcut.R.................   13 tests OK 
test-strcut.R.................   14 tests OK 
test-strcut.R.................   15 tests OK 
test-strcut.R.................   16 tests OK 
test-strcut.R.................   17 tests OK 
test-strcut.R.................   18 tests OK 
test-strcut.R.................   19 tests OK 
test-strcut.R.................   20 tests OK 
test-strcut.R.................   20 tests OK 
test-strcut.R.................   21 tests OK 
test-strcut.R.................   22 tests OK 
test-strcut.R.................   23 tests OK 
test-strcut.R.................   24 tests OK 
test-strcut.R.................   25 tests OK 
test-strcut.R.................   26 tests OK 
test-strcut.R.................   27 tests OK 
test-strcut.R.................   28 tests OK 
test-strcut.R.................   29 tests OK 
test-strcut.R.................   29 tests OK 
test-strcut.R.................   30 tests OK 
test-strcut.R.................   31 tests OK 
test-strcut.R.................   32 tests OK 
test-strcut.R.................   33 tests OK 
test-strcut.R.................   34 tests OK 
test-strcut.R.................   35 tests OK 
test-strcut.R.................   36 tests OK 
test-strcut.R.................   37 tests OK 
test-strcut.R.................   38 tests OK 
test-strcut.R.................   39 tests OK 
test-strcut.R.................   39 tests OK 
test-strcut.R.................   40 tests OK 
test-strcut.R.................   41 tests OK 
test-strcut.R.................   42 tests OK 
test-strcut.R.................   43 tests OK 
test-strcut.R.................   44 tests OK 
test-strcut.R.................   45 tests OK 
test-strcut.R.................   46 tests OK 
test-strcut.R.................   47 tests OK 
test-strcut.R.................   48 tests OK 
test-strcut.R.................   49 tests OK 
test-strcut.R.................   50 tests OK 
test-strcut.R.................   51 tests OK 
test-strcut.R.................   52 tests OK 30ms

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 OK 
test-strfind.R................    2 tests OK 
test-strfind.R................    2 tests OK [1] "abcdefghijklm" "nopqrstuvwxyz" "ABCDEFGHIJKLM" "NOPQRSTUVWXYZ"

test-strfind.R................    2 tests OK 
test-strfind.R................    2 tests OK 
test-strfind.R................    2 tests OK 
test-strfind.R................    3 tests OK 
test-strfind.R................    4 tests OK 
test-strfind.R................    4 tests OK 
test-strfind.R................    4 tests OK 
test-strfind.R................    5 tests OK 
test-strfind.R................    5 tests OK 
test-strfind.R................    5 tests OK 
test-strfind.R................    5 tests OK 
test-strfind.R................    6 tests OK 
test-strfind.R................    6 tests OK 
test-strfind.R................    6 tests OK 
test-strfind.R................    6 tests OK 
test-strfind.R................    7 tests OK 
test-strfind.R................    7 tests OK 
test-strfind.R................    7 tests OK 
test-strfind.R................    7 tests OK 
test-strfind.R................    7 tests OK 
test-strfind.R................    8 tests OK 
test-strfind.R................    9 tests OK 
test-strfind.R................    9 tests OK [1] "abcdefghijklm" "nopqrstuvwxyz" "ABCDEFGHIJKLM" "NOPQRSTUVWXYZ"

test-strfind.R................    9 tests OK 
test-strfind.R................    9 tests OK 
test-strfind.R................    9 tests OK 
test-strfind.R................   10 tests OK 
test-strfind.R................   11 tests OK 
test-strfind.R................   11 tests OK 
test-strfind.R................   11 tests OK 
test-strfind.R................   12 tests OK 
test-strfind.R................   12 tests OK 
test-strfind.R................   12 tests OK 
test-strfind.R................   12 tests OK 
test-strfind.R................   13 tests OK 
test-strfind.R................   13 tests OK 
test-strfind.R................   13 tests OK 
test-strfind.R................   13 tests OK 
test-strfind.R................   14 tests OK 
test-strfind.R................   14 tests OK  [1] "0123456789" "0123456789" "0123456789" "0123456789" "0123456789"
 [6] "0123456789" "0123456789" "0123456789" "0123456789" "0123456789"

test-strfind.R................   14 tests OK 
test-strfind.R................   14 tests OK 
test-strfind.R................   14 tests OK 
test-strfind.R................   14 tests OK 
test-strfind.R................   14 tests OK 
test-strfind.R................   14 tests OK 
test-strfind.R................   14 tests OK 
test-strfind.R................   15 tests OK 
test-strfind.R................   15 tests OK  [1] "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa"
 [6] "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa"

test-strfind.R................   15 tests OK 
test-strfind.R................   15 tests OK 
test-strfind.R................   15 tests OK 
test-strfind.R................   15 tests OK 
test-strfind.R................   15 tests OK 
test-strfind.R................   15 tests OK 
test-strfind.R................   15 tests OK 
test-strfind.R................   16 tests OK 
test-strfind.R................   16 tests OK  [1] "ýýýýýýýýýý" "ýýýýýýýýýý" "ýýýýýýýýýý" "ýýýýýýýýýý" "ýýýýýýýýýý"
 [6] "ýýýýýýýýýý" "ýýýýýýýýýý" "ýýýýýýýýýý" "ýýýýýýýýýý" "ýýýýýýýýýý"

test-strfind.R................   16 tests OK 
test-strfind.R................   16 tests OK 
test-strfind.R................   16 tests OK 
test-strfind.R................   16 tests OK 
test-strfind.R................   16 tests OK 
test-strfind.R................   16 tests OK 
test-strfind.R................   16 tests OK 
test-strfind.R................   17 tests OK 
test-strfind.R................   17 tests OK  [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 OK 
test-strfind.R................   17 tests OK 
test-strfind.R................   17 tests OK 
test-strfind.R................   17 tests OK 
test-strfind.R................   17 tests OK 
test-strfind.R................   17 tests OK 
test-strfind.R................   17 tests OK 
test-strfind.R................   18 tests OK 
test-strfind.R................   18 tests OK  [1] "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa"
 [6] "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa"

test-strfind.R................   18 tests OK 
test-strfind.R................   18 tests OK 
test-strfind.R................   18 tests OK 
test-strfind.R................   18 tests OK 
test-strfind.R................   18 tests OK 
test-strfind.R................   18 tests OK 
test-strfind.R................   18 tests OK 
test-strfind.R................   19 tests OK 
test-strfind.R................   19 tests OK 
test-strfind.R................   19 tests OK 
test-strfind.R................   19 tests OK 
test-strfind.R................   19 tests OK 
test-strfind.R................   19 tests OK 
test-strfind.R................   19 tests OK 
test-strfind.R................   19 tests OK 
test-strfind.R................   19 tests OK 
test-strfind.R................   20 tests OK 
test-strfind.R................   20 tests OK 
test-strfind.R................   20 tests OK 
test-strfind.R................   20 tests OK 
test-strfind.R................   20 tests OK 
test-strfind.R................   20 tests OK ----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : 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 OK 
test-strfind.R................  860 tests OK 
test-strfind.R................  860 tests OK 
test-strfind.R................  860 tests OK 
test-strfind.R................  860 tests OK 
test-strfind.R................  861 tests OK 
test-strfind.R................  862 tests OK 
test-strfind.R................  862 tests OK [1] "abcdefghijklm" "nopqrstuvwxyz" "ABCDEFGHIJKLM" "NOPQRSTUVWXYZ"

test-strfind.R................  862 tests OK 
test-strfind.R................  862 tests OK 
test-strfind.R................  862 tests OK 
test-strfind.R................  863 tests OK 
test-strfind.R................  864 tests OK 
test-strfind.R................  864 tests OK 
test-strfind.R................  864 tests OK 
test-strfind.R................  865 tests OK 
test-strfind.R................  865 tests OK 
test-strfind.R................  865 tests OK 
test-strfind.R................  865 tests OK 
test-strfind.R................  866 tests OK 
test-strfind.R................  866 tests OK 
test-strfind.R................  866 tests OK 
test-strfind.R................  866 tests OK 
test-strfind.R................  866 tests OK 
test-strfind.R................  866 tests OK ----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<288--311>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : 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 OK 
test-strfind.R................ 1706 tests OK 
test-strfind.R................ 1706 tests OK 
test-strfind.R................ 1706 tests OK 
test-strfind.R................ 1706 tests OK 
test-strfind.R................ 1707 tests OK 
test-strfind.R................ 1708 tests OK 
test-strfind.R................ 1708 tests OK [1] "abcdefghijklm" "nopqrstuvwxyz" "ABCDEFGHIJKLM" "NOPQRSTUVWXYZ"

test-strfind.R................ 1708 tests OK 
test-strfind.R................ 1708 tests OK 
test-strfind.R................ 1708 tests OK 
test-strfind.R................ 1709 tests OK 
test-strfind.R................ 1710 tests OK 
test-strfind.R................ 1710 tests OK 
test-strfind.R................ 1710 tests OK 
test-strfind.R................ 1711 tests OK 
test-strfind.R................ 1711 tests OK 
test-strfind.R................ 1711 tests OK 
test-strfind.R................ 1711 tests OK 
test-strfind.R................ 1712 tests OK 
test-strfind.R................ 1712 tests OK 
test-strfind.R................ 1712 tests OK 
test-strfind.R................ 1712 tests OK 
test-strfind.R................ 1712 tests OK 
test-strfind.R................ 1712 tests OK 
test-strfind.R................ 1713 tests OK 
test-strfind.R................ 1713 tests OK 
test-strfind.R................ 1713 tests OK 
test-strfind.R................ 1713 tests OK 
test-strfind.R................ 1713 tests OK 
test-strfind.R................ 1714 tests OK 
test-strfind.R................ 1715 tests OK 
test-strfind.R................ 1715 tests OK [1] "abcdefghijklm" "nopqrstuvwxyz" "ABCDEFGHIJKLM" "NOPQRSTUVWXYZ"

test-strfind.R................ 1715 tests OK 
test-strfind.R................ 1715 tests OK 
test-strfind.R................ 1715 tests OK 
test-strfind.R................ 1716 tests OK 
test-strfind.R................ 1717 tests OK 
test-strfind.R................ 1717 tests OK 
test-strfind.R................ 1717 tests OK 
test-strfind.R................ 1718 tests OK 
test-strfind.R................ 1718 tests OK 
test-strfind.R................ 1718 tests OK 
test-strfind.R................ 1718 tests OK 
test-strfind.R................ 1719 tests OK 
test-strfind.R................ 1719 tests OK 
test-strfind.R................ 1719 tests OK 
test-strfind.R................ 1719 tests OK 
test-strfind.R................ 1719 tests OK 
test-strfind.R................ 1719 tests OK ----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<426--449>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : 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 OK 
test-strfind.R................ 2559 tests OK 
test-strfind.R................ 2559 tests OK 
test-strfind.R................ 2559 tests OK 
test-strfind.R................ 2559 tests OK 
test-strfind.R................ 2560 tests OK 
test-strfind.R................ 2561 tests OK 
test-strfind.R................ 2561 tests OK [1] "abcdefghijklm" "nopqrstuvwxyz" "ABCDEFGHIJKLM" "NOPQRSTUVWXYZ"

test-strfind.R................ 2561 tests OK 
test-strfind.R................ 2561 tests OK 
test-strfind.R................ 2561 tests OK 
test-strfind.R................ 2562 tests OK 
test-strfind.R................ 2563 tests OK 
test-strfind.R................ 2563 tests OK 
test-strfind.R................ 2563 tests OK 
test-strfind.R................ 2564 tests OK 
test-strfind.R................ 2564 tests OK 
test-strfind.R................ 2564 tests OK 
test-strfind.R................ 2564 tests OK 
test-strfind.R................ 2565 tests OK 
test-strfind.R................ 2565 tests OK 
test-strfind.R................ 2565 tests OK 
test-strfind.R................ 2565 tests OK 
test-strfind.R................ 2565 tests OK 
test-strfind.R................ 2565 tests OK ----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<515--538>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : 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 OK 
test-strfind.R................ 3405 tests OK 
test-strfind.R................ 3405 tests OK 
test-strfind.R................ 3405 tests OK 
test-strfind.R................ 3405 tests OK 
test-strfind.R................ 3406 tests OK 
test-strfind.R................ 3407 tests OK 
test-strfind.R................ 3407 tests OK [1] "abcdefghijklm" "nopqrstuvwxyz" "ABCDEFGHIJKLM" "NOPQRSTUVWXYZ"

test-strfind.R................ 3407 tests OK 
test-strfind.R................ 3407 tests OK 
test-strfind.R................ 3407 tests OK 
test-strfind.R................ 3408 tests OK 
test-strfind.R................ 3409 tests OK 
test-strfind.R................ 3409 tests OK 
test-strfind.R................ 3409 tests OK 
test-strfind.R................ 3410 tests OK 
test-strfind.R................ 3410 tests OK 
test-strfind.R................ 3410 tests OK 
test-strfind.R................ 3410 tests OK 
test-strfind.R................ 3411 tests OK 
test-strfind.R................ 3411 tests OK 
test-strfind.R................ 3411 tests OK 
test-strfind.R................ 3412 tests OK 
test-strfind.R................ 3413 tests OK 
test-strfind.R................ 3413 tests OK 
test-strfind.R................ 3413 tests OK 
test-strfind.R................ 3414 tests OK 
test-strfind.R................ 3415 tests OK 
test-strfind.R................ 3416 tests OK 
test-strfind.R................ 3417 tests OK 
test-strfind.R................ 3418 tests OK 
test-strfind.R................ 3419 tests OK 
test-strfind.R................ 3420 tests OK 
test-strfind.R................ 3421 tests OK 
test-strfind.R................ 3422 tests OK 
test-strfind.R................ 3423 tests OK 22.7s

test-stri_join_mat.R..........    0 tests    
test-stri_join_mat.R..........    1 tests OK 
test-stri_join_mat.R..........    2 tests OK 
test-stri_join_mat.R..........    3 tests OK 3ms

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 OK 
test-stri_locate_ith.R........    1 tests OK  [1] "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa"
 [6] "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa"

test-stri_locate_ith.R........    1 tests OK 
test-stri_locate_ith.R........    1 tests OK 
test-stri_locate_ith.R........    1 tests OK 
test-stri_locate_ith.R........    1 tests OK 
test-stri_locate_ith.R........    1 tests OK 
test-stri_locate_ith.R........    1 tests OK 
test-stri_locate_ith.R........    2 tests OK 
test-stri_locate_ith.R........    2 tests OK  [1] "ýýýýýýýýýý" "ýýýýýýýýýý" "ýýýýýýýýýý" "ýýýýýýýýýý" "ýýýýýýýýýý"
 [6] "ýýýýýýýýýý" "ýýýýýýýýýý" "ýýýýýýýýýý" "ýýýýýýýýýý" "ýýýýýýýýýý"

test-stri_locate_ith.R........    2 tests OK 
test-stri_locate_ith.R........    2 tests OK 
test-stri_locate_ith.R........    2 tests OK 
test-stri_locate_ith.R........    2 tests OK 
test-stri_locate_ith.R........    2 tests OK 
test-stri_locate_ith.R........    2 tests OK 
test-stri_locate_ith.R........    3 tests OK 
test-stri_locate_ith.R........    3 tests OK  [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 OK 
test-stri_locate_ith.R........    3 tests OK 
test-stri_locate_ith.R........    3 tests OK 
test-stri_locate_ith.R........    3 tests OK 
test-stri_locate_ith.R........    3 tests OK 
test-stri_locate_ith.R........    3 tests OK 
test-stri_locate_ith.R........    4 tests OK 
test-stri_locate_ith.R........    4 tests OK  [1] "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa"
 [6] "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa"

test-stri_locate_ith.R........    4 tests OK 
test-stri_locate_ith.R........    4 tests OK 
test-stri_locate_ith.R........    4 tests OK 
test-stri_locate_ith.R........    4 tests OK 
test-stri_locate_ith.R........    4 tests OK 
test-stri_locate_ith.R........    4 tests OK 
test-stri_locate_ith.R........    5 tests OK 
test-stri_locate_ith.R........    5 tests OK 
test-stri_locate_ith.R........    5 tests OK 
test-stri_locate_ith.R........    5 tests OK 
test-stri_locate_ith.R........    5 tests OK 
test-stri_locate_ith.R........    5 tests OK 
test-stri_locate_ith.R........    5 tests OK 
test-stri_locate_ith.R........    5 tests OK 
test-stri_locate_ith.R........    5 tests OK 
test-stri_locate_ith.R........    6 tests OK 
test-stri_locate_ith.R........    6 tests OK 
test-stri_locate_ith.R........    6 tests OK 
test-stri_locate_ith.R........    6 tests OK 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.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 =  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 =  3 ; 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 =  3 ; 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 =  3 ; 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 =  3 ; 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 =  3 ; 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 =  4 ; 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 =  4 ; 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 =  4 ; 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 =  4 ; 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 =  4 ; 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 =  4 ; 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 =  4 ; 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 =  4 ; 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 =  4 ; 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 =  4 ; 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 =  5 ; 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 =  5 ; 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 =  5 ; 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 =  5 ; 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 =  5 ; 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 =  5 ; 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 =  5 ; 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 =  5 ; 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 =  5 ; 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 =  5 ; 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"

test-stri_locate_ith.R........  406 tests OK 
test-stri_locate_ith.R........  406 tests OK 
test-stri_locate_ith.R........  406 tests OK 
test-stri_locate_ith.R........  406 tests OK 
test-stri_locate_ith.R........  407 tests OK 
test-stri_locate_ith.R........  408 tests OK 
test-stri_locate_ith.R........  408 tests OK 
test-stri_locate_ith.R........  408 tests OK 
test-stri_locate_ith.R........  408 tests OK 
test-stri_locate_ith.R........  408 tests OK 
test-stri_locate_ith.R........  408 tests OK 
test-stri_locate_ith.R........  408 tests OK 
test-stri_locate_ith.R........  409 tests OK 
test-stri_locate_ith.R........  410 tests OK 
test-stri_locate_ith.R........  410 tests OK 
test-stri_locate_ith.R........  410 tests OK 
test-stri_locate_ith.R........  410 tests OK 
test-stri_locate_ith.R........  410 tests OK 
test-stri_locate_ith.R........  410 tests OK 
test-stri_locate_ith.R........  410 tests OK 
test-stri_locate_ith.R........  411 tests OK 
test-stri_locate_ith.R........  412 tests OK 
test-stri_locate_ith.R........  413 tests OK 
test-stri_locate_ith.R........  413 tests OK [1] "abcdefghijklm" "nopqrstuvwxyz"

test-stri_locate_ith.R........  413 tests OK 
test-stri_locate_ith.R........  413 tests OK 
test-stri_locate_ith.R........  413 tests OK 
test-stri_locate_ith.R........  414 tests OK 
test-stri_locate_ith.R........  414 tests OK 
test-stri_locate_ith.R........  414 tests OK 
test-stri_locate_ith.R........  414 tests OK 
test-stri_locate_ith.R........  414 tests OK 
test-stri_locate_ith.R........  414 tests OK 
test-stri_locate_ith.R........  414 tests OK 
test-stri_locate_ith.R........  415 tests OK 
test-stri_locate_ith.R........  416 tests OK 
test-stri_locate_ith.R........  416 tests OK 
test-stri_locate_ith.R........  416 tests OK 
test-stri_locate_ith.R........  416 tests OK 
test-stri_locate_ith.R........  416 tests OK 
test-stri_locate_ith.R........  416 tests OK 
test-stri_locate_ith.R........  416 tests OK 
test-stri_locate_ith.R........  417 tests OK 
test-stri_locate_ith.R........  418 tests OK 
test-stri_locate_ith.R........  419 tests OK 
test-stri_locate_ith.R........  419 tests OK 
test-stri_locate_ith.R........  419 tests OK 
test-stri_locate_ith.R........  420 tests OK 
test-stri_locate_ith.R........  420 tests OK 
test-stri_locate_ith.R........  420 tests OK 
test-stri_locate_ith.R........  420 tests OK 
test-stri_locate_ith.R........  420 tests OK 
test-stri_locate_ith.R........  420 tests OK 
test-stri_locate_ith.R........  420 tests OK 
test-stri_locate_ith.R........  420 tests OK 
test-stri_locate_ith.R........  421 tests OK 
test-stri_locate_ith.R........  422 tests OK 
test-stri_locate_ith.R........  422 tests OK 
test-stri_locate_ith.R........  422 tests OK 
test-stri_locate_ith.R........  422 tests OK 
test-stri_locate_ith.R........  422 tests OK 
test-stri_locate_ith.R........  422 tests OK 
test-stri_locate_ith.R........  422 tests OK 
test-stri_locate_ith.R........  422 tests OK 
test-stri_locate_ith.R........  423 tests OK 
test-stri_locate_ith.R........  424 tests OK 
test-stri_locate_ith.R........  425 tests OK 
test-stri_locate_ith.R........  425 tests OK 
test-stri_locate_ith.R........  425 tests OK 
test-stri_locate_ith.R........  425 tests OK 
test-stri_locate_ith.R........  426 tests OK 
test-stri_locate_ith.R........  427 tests OK 
test-stri_locate_ith.R........  428 tests OK 
test-stri_locate_ith.R........  428 tests OK 
test-stri_locate_ith.R........  428 tests OK 
test-stri_locate_ith.R........  428 tests OK 
test-stri_locate_ith.R........  428 tests OK 
test-stri_locate_ith.R........  428 tests OK 
test-stri_locate_ith.R........  428 tests OK 
test-stri_locate_ith.R........  429 tests OK 
test-stri_locate_ith.R........  430 tests OK 
test-stri_locate_ith.R........  431 tests OK 
test-stri_locate_ith.R........  431 tests OK 
test-stri_locate_ith.R........  431 tests OK 
test-stri_locate_ith.R........  432 tests OK 
test-stri_locate_ith.R........  433 tests OK 
test-stri_locate_ith.R........  434 tests OK 
test-stri_locate_ith.R........  434 tests OK 
test-stri_locate_ith.R........  434 tests OK 
test-stri_locate_ith.R........  434 tests OK 
test-stri_locate_ith.R........  434 tests OK 
test-stri_locate_ith.R........  434 tests OK 
test-stri_locate_ith.R........  435 tests OK 
test-stri_locate_ith.R........  436 tests OK 
test-stri_locate_ith.R........  437 tests OK 
test-stri_locate_ith.R........  437 tests OK 
test-stri_locate_ith.R........  437 tests OK 
test-stri_locate_ith.R........  438 tests OK 
test-stri_locate_ith.R........  438 tests OK 
test-stri_locate_ith.R........  438 tests OK 
test-stri_locate_ith.R........  439 tests OK 
test-stri_locate_ith.R........  439 tests OK 
test-stri_locate_ith.R........  440 tests OK 
test-stri_locate_ith.R........  440 tests OK 
test-stri_locate_ith.R........  440 tests OK 
test-stri_locate_ith.R........  441 tests OK 
test-stri_locate_ith.R........  442 tests OK 
test-stri_locate_ith.R........  443 tests OK 
test-stri_locate_ith.R........  443 tests OK 
test-stri_locate_ith.R........  443 tests OK 
test-stri_locate_ith.R........  444 tests OK 
test-stri_locate_ith.R........  444 tests OK 
test-stri_locate_ith.R........  444 tests OK 
test-stri_locate_ith.R........  444 tests OK 
test-stri_locate_ith.R........  444 tests OK 
test-stri_locate_ith.R........  445 tests OK 1.2s
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-x.import.R...............    0 tests    
test-x.import.R...............    0 tests    
test-x.import.R...............    1 tests OK 
test-x.import.R...............    2 tests OK 
test-x.import.R...............    3 tests OK 
test-x.import.R...............    4 tests OK 
test-x.import.R...............    5 tests OK 
test-x.import.R...............    6 tests OK 
test-x.import.R...............    7 tests OK 
test-x.import.R...............    8 tests OK 
test-x.import.R...............    9 tests OK 
test-x.import.R...............   10 tests OK 
test-x.import.R...............   11 tests OK 
test-x.import.R...............   12 tests OK 
test-x.import.R...............   13 tests OK 
test-x.import.R...............   13 tests OK Checking for conflicting infix operators in the current environment...
Placing infix operators in current environment...
Done

test-x.import.R...............   14 tests OK 
test-x.import.R...............   14 tests OK exposing and locking functions to current environment ...
Done

test-x.import.R...............   15 tests OK 
test-x.import.R...............   15 tests OK 
test-x.import.R...............   16 tests OK 56ms

test_tinycodet.R..............    1 tests OK 
test_tinycodet.R..............    2 tests OK 5ms

test-aaa.R....................    0 tests    
test-aaa.R....................    0 tests    [1] "D:\\temp\\RtmpGQzHE7/fake_lib1/tinycodetfakepkg1"
[1] "D:\\temp\\RtmpGQzHE7/fake_lib1/tinycodetfakepkg2"
[1] "D:\\temp\\RtmpGQzHE7/fake_lib1/tinycodetfakepkg3"
[1] "D:\\temp\\RtmpGQzHE7/fake_lib1/tinycodetfakepkg4"
[1] "D:\\temp\\RtmpGQzHE7/fake_lib1/tinycodetfakepkg5"
[1] "D:\\temp\\RtmpGQzHE7/fake_lib2/tinycodetfakepkg3"
[1] "D:\\temp\\RtmpGQzHE7/fake_lib3/tinycodetfakepkg1"
[1] "D:\\temp\\RtmpGQzHE7/fake_lib3/tinycodetfakepkg2"

test-aaa.R....................    0 tests    
test-aaa.R....................    1 tests OK 
test-aaa.R....................    2 tests OK 
test-aaa.R....................    3 tests OK 55ms

test-import_as-special.R......    0 tests    
test-import_as-special.R......    0 tests    
test-import_as-special.R......    0 tests    
test-import_as-special.R......    0 tests    
test-import_as-special.R......    0 tests    [1] "D:\\temp\\RtmpGQzHE7/fake_lib1"

test-import_as-special.R......    0 tests    [1] "D:\\temp\\RtmpGQzHE7/fake_lib2"

test-import_as-special.R......    0 tests    [1] "D:\\temp\\RtmpGQzHE7/fake_lib3"

test-import_as-special.R......    0 tests    
test-import_as-special.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-special.R......    0 tests    
test-import_as-special.R......    0 tests    
test-import_as-special.R......    1 tests OK 
test-import_as-special.R......    2 tests OK 
test-import_as-special.R......    3 tests OK 
test-import_as-special.R......    3 tests OK 
test-import_as-special.R......    4 tests OK 
test-import_as-special.R......    5 tests OK 
test-import_as-special.R......    5 tests OK 
test-import_as-special.R......    6 tests OK 
test-import_as-special.R......    7 tests OK 
test-import_as-special.R......    8 tests OK 
test-import_as-special.R......    9 tests OK 
test-import_as-special.R......   10 tests OK 
test-import_as-special.R......   11 tests OK Importing packages and registering methods...
Done
You can now access the functions using `p3.$`
For conflicts report, packages order, and other attributes, run `attr.import(p3.)` 


test-import_as-special.R......   11 tests OK 
test-import_as-special.R......   11 tests OK 
test-import_as-special.R......   11 tests OK 
test-import_as-special.R......   12 tests OK 
test-import_as-special.R......   13 tests OK 
test-import_as-special.R......   14 tests OK Importing packages and registering methods...
Done
You can now access the functions using `p3.$`
For conflicts report, packages order, and other attributes, run `attr.import(p3.)` 

Importing packages and registering methods...
Done
You can now access the functions using `p3.$`
For conflicts report, packages order, and other attributes, run `attr.import(p3.)` 


test-import_as-special.R......   15 tests OK Importing packages and registering methods...
Done
You can now access the functions using `p3.$`
For conflicts report, packages order, and other attributes, run `attr.import(p3.)` 


test-import_as-special.R......   15 tests OK 
test-import_as-special.R......   15 tests OK 
test-import_as-special.R......   15 tests OK 
test-import_as-special.R......   16 tests OK 
test-import_as-special.R......   17 tests OK 
test-import_as-special.R......   18 tests OK Importing packages and registering methods...
Done
You can now access the functions using `p3.$`
For conflicts report, packages order, and other attributes, run `attr.import(p3.)` 


test-import_as-special.R......   18 tests OK 
test-import_as-special.R......   18 tests OK 
test-import_as-special.R......   18 tests OK 
test-import_as-special.R......   19 tests OK 
test-import_as-special.R......   20 tests OK 
test-import_as-special.R......   21 tests OK 
test-import_as-special.R......   21 tests OK 
test-import_as-special.R......   21 tests OK 
test-import_as-special.R......   22 tests OK 
test-import_as-special.R......   22 tests OK 
test-import_as-special.R......   22 tests OK 
test-import_as-special.R......   23 tests OK 
test-import_as-special.R......   23 tests OK 
test-import_as-special.R......   23 tests OK 
test-import_as-special.R......   24 tests OK 
test-import_as-special.R......   25 tests OK 
test-import_as-special.R......   25 tests OK 
test-import_as-special.R......   26 tests OK 
test-import_as-special.R......   26 tests OK 
test-import_as-special.R......   27 tests OK 
test-import_as-special.R......   27 tests OK 
test-import_as-special.R......   28 tests OK 
test-import_as-special.R......   28 tests OK 
test-import_as-special.R......   29 tests OK 
test-import_as-special.R......   29 tests OK 
test-import_as-special.R......   30 tests OK 
test-import_as-special.R......   30 tests OK 
test-import_as-special.R......   31 tests OK 
test-import_as-special.R......   31 tests OK 
test-import_as-special.R......   32 tests OK 0.4s

test-import_general-special.R.    0 tests    
test-import_general-special.R.    0 tests    
test-import_general-special.R.    0 tests    
test-import_general-special.R.    0 tests    
test-import_general-special.R.    0 tests    [1] "D:\\temp\\RtmpGQzHE7/fake_lib1"

test-import_general-special.R.    0 tests    [1] "D:\\temp\\RtmpGQzHE7/fake_lib2"

test-import_general-special.R.    0 tests    [1] "D:\\temp\\RtmpGQzHE7/fake_lib3"

test-import_general-special.R.    0 tests    Importing packages and registering methods...
Done
You can now access the functions using `new.$`
For conflicts report, packages order, and other attributes, run `attr.import(new.)` 


test-import_general-special.R.    0 tests    
test-import_general-special.R.    1 tests OK 
test-import_general-special.R.    1 tests OK Checking for conflicting infix operators in the current environment...
Placing infix operators in current environment...
Done

test-import_general-special.R.    2 tests OK 
test-import_general-special.R.    2 tests OK exposing and locking functions to current environment ...
Done

test-import_general-special.R.    3 tests OK 
test-import_general-special.R.    3 tests OK Importing packages and registering methods...

test-import_general-special.R.    4 tests OK Importing packages and registering methods...

test-import_general-special.R.    5 tests OK Importing packages and registering methods...

test-import_general-special.R.    6 tests OK 
test-import_general-special.R.    7 tests OK 
test-import_general-special.R.    8 tests OK Importing packages and registering methods...
Done
You can now access the functions using `p3.$`
For conflicts report, packages order, and other attributes, run `attr.import(p3.)` 


test-import_general-special.R.    8 tests OK 
test-import_general-special.R.    8 tests OK 
test-import_general-special.R.    8 tests OK 
test-import_general-special.R.    8 tests OK 
test-import_general-special.R.    8 tests OK 
test-import_general-special.R.    8 tests OK 
test-import_general-special.R.    8 tests OK 
test-import_general-special.R.    9 tests OK 
test-import_general-special.R.    9 tests OK 
test-import_general-special.R.    9 tests OK Importing packages and registering methods...
Done
You can now access the functions using `p3.$`
For conflicts report, packages order, and other attributes, run `attr.import(p3.)` 

Checking for conflicting infix operators in the current environment...
Placing infix operators in current environment...
Done

test-import_general-special.R.    9 tests OK 
test-import_general-special.R.   10 tests OK 
test-import_general-special.R.   10 tests OK 
test-import_general-special.R.   10 tests OK exposing and locking functions to current environment ...
Done
exposing and locking functions to current environment ...
Done
exposing and locking functions to current environment ...
Done

test-import_general-special.R.   10 tests OK 
test-import_general-special.R.   11 tests OK 0.1s

test-import_inops-alias-special.R    0 tests    
test-import_inops-alias-special.R    0 tests    
test-import_inops-alias-special.R    0 tests    
test-import_inops-alias-special.R    0 tests    
test-import_inops-alias-special.R    0 tests    [1] "D:\\temp\\RtmpGQzHE7/fake_lib1"

test-import_inops-alias-special.R    0 tests    [1] "D:\\temp\\RtmpGQzHE7/fake_lib2"

test-import_inops-alias-special.R    0 tests    [1] "D:\\temp\\RtmpGQzHE7/fake_lib3"

test-import_inops-alias-special.R    0 tests    
test-import_inops-alias-special.R    0 tests    Importing packages and registering methods...
Done
You can now access the functions using `to3.$`
For conflicts report, packages order, and other attributes, run `attr.import(to3.)` 

Checking for conflicting infix operators in the current environment...
Placing infix operators in current environment...
Done

test-import_inops-alias-special.R    1 tests OK 
test-import_inops-alias-special.R    1 tests OK Importing packages and registering methods...
Done
You can now access the functions using `to3.$`
For conflicts report, packages order, and other attributes, run `attr.import(to3.)` 

Checking for conflicting infix operators in the current environment...
Placing infix operators in current environment...
Done

test-import_inops-alias-special.R    2 tests OK 
test-import_inops-alias-special.R    2 tests OK Importing packages and registering methods...
Done
You can now access the functions using `to3.$`
For conflicts report, packages order, and other attributes, run `attr.import(to3.)` 

Checking for conflicting infix operators in the current environment...
Placing infix operators in current environment...
Done

test-import_inops-alias-special.R    3 tests OK 
test-import_inops-alias-special.R    3 tests OK Importing packages and registering methods...
Done
You can now access the functions using `to3.$`
For conflicts report, packages order, and other attributes, run `attr.import(to3.)` 

Checking for conflicting infix operators in the current environment...
Placing infix operators in current environment...
Done
unexposing infix operators...
Done

test-import_inops-alias-special.R    4 tests OK 
test-import_inops-alias-special.R    4 tests OK Importing packages and registering methods...
Done
You can now access the functions using `to3.$`
For conflicts report, packages order, and other attributes, run `attr.import(to3.)` 

Checking for conflicting infix operators in the current environment...
Placing infix operators in current environment...
Done

test-import_inops-alias-special.R    5 tests OK 0.2s

test-import_inops-pkgs-special.R    0 tests    
test-import_inops-pkgs-special.R    0 tests    
test-import_inops-pkgs-special.R    0 tests    
test-import_inops-pkgs-special.R    0 tests    
test-import_inops-pkgs-special.R    0 tests    [1] "D:\\temp\\RtmpGQzHE7/fake_lib1"

test-import_inops-pkgs-special.R    0 tests    [1] "D:\\temp\\RtmpGQzHE7/fake_lib2"

test-import_inops-pkgs-special.R    0 tests    [1] "D:\\temp\\RtmpGQzHE7/fake_lib3"

test-import_inops-pkgs-special.R    0 tests    
test-import_inops-pkgs-special.R    0 tests    Checking for conflicting infix operators in the current environment...
Placing infix operators in current environment...
Done

test-import_inops-pkgs-special.R    1 tests OK 
test-import_inops-pkgs-special.R    1 tests OK Checking for conflicting infix operators in the current environment...
Placing infix operators in current environment...
Done

test-import_inops-pkgs-special.R    2 tests OK 
test-import_inops-pkgs-special.R    2 tests OK Checking for conflicting infix operators in the current environment...
Placing infix operators in current environment...
Done

test-import_inops-pkgs-special.R    3 tests OK 
test-import_inops-pkgs-special.R    3 tests OK 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...
The following infix operators already exist in the current environment:
%opover%
Overwriting existing infix operators...
Placing infix operators in current environment...
Done
Checking for conflicting infix operators in the current environment...
The following infix operators already exist in the current environment:
%opover%
Overwriting existing infix operators...
Placing infix operators in current environment...
Done
checking for infix operators exposed to the current environment by `import_inops()` ...
Removing the following infix operators:
%op21%, %op22%
Done
checking for infix operators exposed to the current environment by `import_inops()` ...
Removing the following infix operators:
%op31%, %op32%, %opover%
Done

test-import_inops-pkgs-special.R    4 tests OK 
test-import_inops-pkgs-special.R    4 tests OK 
test-import_inops-pkgs-special.R    5 tests OK 
test-import_inops-pkgs-special.R    5 tests OK 
test-import_inops-pkgs-special.R    6 tests OK 
test-import_inops-pkgs-special.R    6 tests OK 
test-import_inops-pkgs-special.R    7 tests OK checking for infix operators exposed to the current environment by `import_inops()` ...
No infix operators from `import_inops()` to delete

test-import_inops-pkgs-special.R    8 tests OK 
test-import_inops-pkgs-special.R    9 tests OK 
test-import_inops-pkgs-special.R    9 tests OK Checking for conflicting infix operators in the current environment...
Placing infix operators in current environment...
Done

test-import_inops-pkgs-special.R   10 tests OK 68ms

test-import_int-special.R.....    0 tests    
test-import_int-special.R.....    0 tests    
test-import_int-special.R.....    0 tests    
test-import_int-special.R.....    0 tests    
test-import_int-special.R.....    0 tests    [1] "D:\\temp\\RtmpGQzHE7/fake_lib1"

test-import_int-special.R.....    0 tests    [1] "D:\\temp\\RtmpGQzHE7/fake_lib2"

test-import_int-special.R.....    0 tests    [1] "D:\\temp\\RtmpGQzHE7/fake_lib3"

test-import_int-special.R.....    0 tests    
test-import_int-special.R.....    1 tests OK 
test-import_int-special.R.....    2 tests OK 
test-import_int-special.R.....    3 tests OK 
test-import_int-special.R.....    4 tests OK 
test-import_int-special.R.....    5 tests OK 
test-import_int-special.R.....    6 tests OK 
test-import_int-special.R.....    7 tests OK 
test-import_int-special.R.....    8 tests OK 
test-import_int-special.R.....    9 tests OK 
test-import_int-special.R.....   10 tests OK 
test-import_int-special.R.....   11 tests OK 
test-import_int-special.R.....   12 tests OK 
test-import_int-special.R.....   13 tests OK 36ms

test-pkgs-special.R...........    0 tests    
test-pkgs-special.R...........    0 tests    
test-pkgs-special.R...........    0 tests    
test-pkgs-special.R...........    0 tests    
test-pkgs-special.R...........    0 tests    [1] "D:\\temp\\RtmpGQzHE7/fake_lib1"

test-pkgs-special.R...........    0 tests    [1] "D:\\temp\\RtmpGQzHE7/fake_lib2"

test-pkgs-special.R...........    0 tests    [1] "D:\\temp\\RtmpGQzHE7/fake_lib3"

test-pkgs-special.R...........    0 tests    
test-pkgs-special.R...........    1 tests OK 
test-pkgs-special.R...........    2 tests OK 
test-pkgs-special.R...........    3 tests OK 
test-pkgs-special.R...........    4 tests OK 
test-pkgs-special.R...........    5 tests OK 
test-pkgs-special.R...........    6 tests OK 
test-pkgs-special.R...........    7 tests OK 
test-pkgs-special.R...........    8 tests OK 
test-pkgs-special.R...........    9 tests OK 
test-pkgs-special.R...........   10 tests OK 
test-pkgs-special.R...........   11 tests OK 
test-pkgs-special.R...........   12 tests OK 
test-pkgs-special.R...........   13 tests OK 
test-pkgs-special.R...........   14 tests OK 
test-pkgs-special.R...........   15 tests OK 
test-pkgs-special.R...........   16 tests OK 
test-pkgs-special.R...........   17 tests OK 
test-pkgs-special.R...........   18 tests OK 
test-pkgs-special.R...........   18 tests OK 
test-pkgs-special.R...........   18 tests OK 
test-pkgs-special.R...........   18 tests OK 
test-pkgs-special.R...........   18 tests OK 
test-pkgs-special.R...........   18 tests OK 
test-pkgs-special.R...........   18 tests OK 
test-pkgs-special.R...........   18 tests OK 
test-pkgs-special.R...........   19 tests OK 
test-pkgs-special.R...........   20 tests OK 
test-pkgs-special.R...........   21 tests OK 
test-pkgs-special.R...........   22 tests OK 
test-pkgs-special.R...........   23 tests OK 66ms

test-zzz.R....................    0 tests    
test-zzz.R....................    0 tests    
test-zzz.R....................    0 tests    
test-zzz.R....................    1 tests OK 31ms
All ok, 98 results (0.9s)
There were 50 or more warnings (use warnings() to see the first 50)
> 
> 
> proc.time()
   user  system elapsed 
 108.90    1.78  110.67