R Under development (unstable) (2024-01-10 r85799 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 
test-atomic_conversions.R.....   19 tests OK 
test-atomic_conversions.R.....   20 tests OK 
test-atomic_conversions.R.....   21 tests OK 
test-atomic_conversions.R.....   22 tests OK 
test-atomic_conversions.R.....   23 tests OK 
test-atomic_conversions.R.....   23 tests OK 
test-atomic_conversions.R.....   24 tests OK 
test-atomic_conversions.R.....   25 tests OK 
test-atomic_conversions.R.....   26 tests OK 
test-atomic_conversions.R.....   27 tests OK 
test-atomic_conversions.R.....   28 tests OK 84ms

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_truth.R..........    0 tests    
test-decimal_truth.R..........    0 tests    
test-decimal_truth.R..........    1 tests OK 
test-decimal_truth.R..........    2 tests OK 
test-decimal_truth.R..........    3 tests OK 
test-decimal_truth.R..........    4 tests OK 
test-decimal_truth.R..........    5 tests OK 
test-decimal_truth.R..........    6 tests OK 
test-decimal_truth.R..........    7 tests OK 
test-decimal_truth.R..........    8 tests OK 
test-decimal_truth.R..........    9 tests OK 
test-decimal_truth.R..........   10 tests OK 
test-decimal_truth.R..........   11 tests OK 
test-decimal_truth.R..........   12 tests OK 
test-decimal_truth.R..........   13 tests OK 
test-decimal_truth.R..........   14 tests OK 
test-decimal_truth.R..........   15 tests OK 
test-decimal_truth.R..........   16 tests OK 
test-decimal_truth.R..........   17 tests OK 
test-decimal_truth.R..........   18 tests OK 
test-decimal_truth.R..........   18 tests OK 
test-decimal_truth.R..........   18 tests OK 
test-decimal_truth.R..........   18 tests OK 
test-decimal_truth.R..........   19 tests OK 
test-decimal_truth.R..........   20 tests OK 
test-decimal_truth.R..........   21 tests OK 
test-decimal_truth.R..........   22 tests OK 
test-decimal_truth.R..........   23 tests OK 
test-decimal_truth.R..........   24 tests OK 
test-decimal_truth.R..........   25 tests OK 
test-decimal_truth.R..........   26 tests OK 
test-decimal_truth.R..........   27 tests OK 
test-decimal_truth.R..........   28 tests OK 
test-decimal_truth.R..........   29 tests OK 
test-decimal_truth.R..........   30 tests OK 
test-decimal_truth.R..........   31 tests OK 
test-decimal_truth.R..........   32 tests OK 
test-decimal_truth.R..........   33 tests OK 
test-decimal_truth.R..........   34 tests OK 
test-decimal_truth.R..........   35 tests OK 
test-decimal_truth.R..........   36 tests OK 
test-decimal_truth.R..........   36 tests OK 
test-decimal_truth.R..........   36 tests OK 
test-decimal_truth.R..........   37 tests OK 
test-decimal_truth.R..........   38 tests OK 
test-decimal_truth.R..........   39 tests OK 
test-decimal_truth.R..........   40 tests OK 
test-decimal_truth.R..........   41 tests OK 
test-decimal_truth.R..........   42 tests OK 
test-decimal_truth.R..........   43 tests OK 
test-decimal_truth.R..........   44 tests OK 
test-decimal_truth.R..........   45 tests OK 
test-decimal_truth.R..........   46 tests OK 
test-decimal_truth.R..........   46 tests OK 
test-decimal_truth.R..........   46 tests OK 
test-decimal_truth.R..........   47 tests OK 
test-decimal_truth.R..........   48 tests OK 
test-decimal_truth.R..........   49 tests OK 
test-decimal_truth.R..........   50 tests OK 
test-decimal_truth.R..........   51 tests OK 
test-decimal_truth.R..........   52 tests OK 
test-decimal_truth.R..........   53 tests OK 
test-decimal_truth.R..........   54 tests OK 
test-decimal_truth.R..........   55 tests OK 
test-decimal_truth.R..........   56 tests OK 
test-decimal_truth.R..........   57 tests OK 
test-decimal_truth.R..........   58 tests OK 
test-decimal_truth.R..........   59 tests OK 
test-decimal_truth.R..........   60 tests OK 
test-decimal_truth.R..........   61 tests OK 
test-decimal_truth.R..........   62 tests OK 
test-decimal_truth.R..........   63 tests OK 
test-decimal_truth.R..........   64 tests OK 16ms

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.1s

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 59ms

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 5ms

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<36--57>
 call| expect_error(import_as(~stri., i), pattern = pattern) 
----- PASSED      : test-import_general.R<36--57>
 call| expect_error(import_inops(i), pattern = pattern) 
----- PASSED      : test-import_general.R<36--57>
 call| expect_error(import_LL(i, "foo"), pattern = pattern) 
----- PASSED      : test-import_general.R<36--57>
 call| expect_error(pversion_check4mismatch(i), pattern = pattern) 
----- PASSED      : test-import_general.R<36--57>
 call| expect_error(pversion_report(i), pattern = pattern) 
----- PASSED      : test-import_general.R<36--57>
 call| expect_error(import_as(~stri., i), pattern = pattern) 
----- PASSED      : test-import_general.R<36--57>
 call| expect_error(import_inops(i), pattern = pattern) 
----- PASSED      : test-import_general.R<36--57>
 call| expect_error(import_LL(i, "foo"), pattern = pattern) 
----- PASSED      : test-import_general.R<36--57>
 call| expect_error(pversion_check4mismatch(i), pattern = pattern) 
----- PASSED      : test-import_general.R<36--57>
 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 ----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_as(~stri., i), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_inops(i), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_LL(i, "foo"), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_int(form), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_as(~stri., i), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_inops(i), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_LL(i, "foo"), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_int(form), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_as(~stri., i), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_inops(i), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_LL(i, "foo"), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_int(form), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_as(~stri., i), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_inops(i), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_LL(i, "foo"), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_int(form), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_as(~stri., i), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_inops(i), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_LL(i, "foo"), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_int(form), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_as(~stri., i), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_inops(i), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_LL(i, "foo"), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_int(form), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_as(~stri., i), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_inops(i), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_LL(i, "foo"), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_int(form), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_as(~stri., i), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_inops(i), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_LL(i, "foo"), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_int(form), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_as(~stri., i), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_inops(i), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_LL(i, "foo"), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_int(form), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_as(~stri., i), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_inops(i), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_LL(i, "foo"), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_int(form), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_as(~stri., i), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_inops(i), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_LL(i, "foo"), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_int(form), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_as(~stri., i), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_inops(i), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_LL(i, "foo"), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_int(form), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_as(~stri., i), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_inops(i), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_LL(i, "foo"), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_int(form), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_as(~stri., i), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_inops(i), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_LL(i, "foo"), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_int(form), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_as(~stri., i), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_inops(i), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 call| expect_error(import_LL(i, "foo"), pattern = pattern) 
----- PASSED      : test-import_general.R<71--89>
 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 ----- PASSED      : test-import_general.R<97--123>
 call| expect_error(import_as(~stri., i), pattern = pattern) 
----- PASSED      : test-import_general.R<97--123>
 call| expect_error(import_inops(i), pattern = pattern) 
----- PASSED      : test-import_general.R<97--123>
 call| expect_error(import_LL(i, "foo"), pattern = pattern) 
----- PASSED      : test-import_general.R<97--123>
 call| expect_error(import_int(form), pattern = pattern) 
----- PASSED      : test-import_general.R<97--123>
 call| expect_error(pversion_check4mismatch(i), pattern = pattern) 
----- PASSED      : test-import_general.R<97--123>
 call| expect_error(pversion_report(i), pattern = pattern) 
----- PASSED      : test-import_general.R<97--123>
 call| expect_error(import_as(~stri., i), pattern = pattern) 
----- PASSED      : test-import_general.R<97--123>
 call| expect_error(import_inops(i), pattern = pattern) 
----- PASSED      : test-import_general.R<97--123>
 call| expect_error(import_LL(i, "foo"), pattern = pattern) 
----- PASSED      : test-import_general.R<97--123>
 call| expect_error(import_int(form), pattern = pattern) 
----- PASSED      : test-import_general.R<97--123>
 call| expect_error(pversion_check4mismatch(i), pattern = pattern) 
----- PASSED      : test-import_general.R<97--123>
 call| expect_error(pversion_report(i), pattern = pattern) 
----- PASSED      : test-import_general.R<97--123>
 call| expect_error(import_as(~stri., i), pattern = pattern) 
----- PASSED      : test-import_general.R<97--123>
 call| expect_error(import_inops(i), pattern = pattern) 
----- PASSED      : test-import_general.R<97--123>
 call| expect_error(import_LL(i, "foo"), pattern = pattern) 
----- PASSED      : test-import_general.R<97--123>
 call| expect_error(import_int(form), pattern = pattern) 
----- PASSED      : test-import_general.R<97--123>
 call| expect_error(pversion_check4mismatch(i), pattern = pattern) 
----- PASSED      : test-import_general.R<97--123>
 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.3s

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.1s

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 92ms

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.3s

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 27ms

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.2s

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 3ms

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 14ms

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 3ms

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 42ms

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

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 7ms

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 14ms

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.........    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 32ms

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 3.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    ----- PASSED      : test-str_search_at.R<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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<30--71>
 call| expect_equal(x[[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 7.5s

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.........    8 tests OK 
test-str_subset_ops.R.........    9 tests OK 
test-str_subset_ops.R.........   10 tests OK 7ms

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.................    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.................   19 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.................   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 19ms

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 ----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind.R<198--221>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : 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 4.3s

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 2ms

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 iX =  1 ; iP =  1 ; iCI =  TRUE 
----- PASSED      : test-stri_locate_ith.R<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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<91--156>
 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 42.3s
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 49ms

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

test-aaa.R....................    0 tests    
test-aaa.R....................    0 tests    [1] "D:\\temp\\RtmpAxOUOd/fake_lib1/tinycodetfakepkg1"
[1] "D:\\temp\\RtmpAxOUOd/fake_lib1/tinycodetfakepkg2"
[1] "D:\\temp\\RtmpAxOUOd/fake_lib1/tinycodetfakepkg3"
[1] "D:\\temp\\RtmpAxOUOd/fake_lib1/tinycodetfakepkg4"
[1] "D:\\temp\\RtmpAxOUOd/fake_lib1/tinycodetfakepkg5"
[1] "D:\\temp\\RtmpAxOUOd/fake_lib2/tinycodetfakepkg3"
[1] "D:\\temp\\RtmpAxOUOd/fake_lib3/tinycodetfakepkg1"
[1] "D:\\temp\\RtmpAxOUOd/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 48ms

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\\RtmpAxOUOd/fake_lib1"

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

test-import_as-special.R......    0 tests    [1] "D:\\temp\\RtmpAxOUOd/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\\RtmpAxOUOd/fake_lib1"

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

test-import_general-special.R.    0 tests    [1] "D:\\temp\\RtmpAxOUOd/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\\RtmpAxOUOd/fake_lib1"

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

test-import_inops-alias-special.R    0 tests    [1] "D:\\temp\\RtmpAxOUOd/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\\RtmpAxOUOd/fake_lib1"

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

test-import_inops-pkgs-special.R    0 tests    [1] "D:\\temp\\RtmpAxOUOd/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 67ms

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\\RtmpAxOUOd/fake_lib1"

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

test-import_int-special.R.....    0 tests    [1] "D:\\temp\\RtmpAxOUOd/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\\RtmpAxOUOd/fake_lib1"

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

test-pkgs-special.R...........    0 tests    [1] "D:\\temp\\RtmpAxOUOd/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 70ms

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