R Under development (unstable) (2024-07-20 r86909 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", set_env=list(LC_COLLATE="C"))
+   tinytest::test_package("tinycodet", testdir = file.path("tinytest", "safer"), set_env=list(LC_COLLATE="C"))
+   tinytest::test_package("tinycodet", testdir = file.path("tinytest", "import"), set_env=list(LC_COLLATE="C"))
+   tinytest::test_package("tinycodet", testdir = file.path("tinytest", "strings"), set_env=list(LC_COLLATE="C"))
+   tinytest::test_package("tinycodet", testdir = file.path("tinytest", "dry"), set_env=list(LC_COLLATE="C"))
+ 
+   # perform special tests on fake packages:
+   tinytest::test_package("tinycodet", testdir = file.path("tinytest", "special"), set_env=list(LC_COLLATE="C"))
+ }
Run `?tinycodet::tinycodet` to open the introduction help page of 'tinycodet'.

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

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

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

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

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

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

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

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

test-decimal-eq.R.............    0 tests    
test-decimal-eq.R.............    0 tests    
test-decimal-eq.R.............    0 tests    
test-decimal-eq.R.............    0 tests    
test-decimal-eq.R.............    0 tests    
test-decimal-eq.R.............    0 tests    
test-decimal-eq.R.............    0 tests    
test-decimal-eq.R.............    0 tests    
test-decimal-eq.R.............    0 tests    
test-decimal-eq.R.............    1 tests OK 
test-decimal-eq.R.............    2 tests OK 
test-decimal-eq.R.............    3 tests OK 
test-decimal-eq.R.............    4 tests OK 
test-decimal-eq.R.............    5 tests OK 
test-decimal-eq.R.............    6 tests OK 
test-decimal-eq.R.............    7 tests OK 
test-decimal-eq.R.............    8 tests OK 
test-decimal-eq.R.............    9 tests OK 
test-decimal-eq.R.............    9 tests OK 
test-decimal-eq.R.............   10 tests OK 
test-decimal-eq.R.............   11 tests OK 
test-decimal-eq.R.............   12 tests OK 
test-decimal-eq.R.............   13 tests OK 
test-decimal-eq.R.............   14 tests OK 
test-decimal-eq.R.............   15 tests OK 
test-decimal-eq.R.............   15 tests OK 
test-decimal-eq.R.............   15 tests OK 
test-decimal-eq.R.............   15 tests OK 
test-decimal-eq.R.............   16 tests OK 
test-decimal-eq.R.............   17 tests OK 
test-decimal-eq.R.............   18 tests OK 
test-decimal-eq.R.............   19 tests OK 
test-decimal-eq.R.............   20 tests OK 
test-decimal-eq.R.............   21 tests OK 
test-decimal-eq.R.............   22 tests OK 
test-decimal-eq.R.............   23 tests OK 
test-decimal-eq.R.............   24 tests OK 
test-decimal-eq.R.............   25 tests OK 
test-decimal-eq.R.............   26 tests OK 
test-decimal-eq.R.............   27 tests OK 
test-decimal-eq.R.............   28 tests OK 
test-decimal-eq.R.............   29 tests OK 
test-decimal-eq.R.............   30 tests OK 
test-decimal-eq.R.............   31 tests OK 
test-decimal-eq.R.............   32 tests OK 
test-decimal-eq.R.............   33 tests OK 
test-decimal-eq.R.............   33 tests OK 
test-decimal-eq.R.............   33 tests OK 
test-decimal-eq.R.............   33 tests OK 
test-decimal-eq.R.............   33 tests OK ----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x == y, x %d==% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x != y, x %d!=% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x <= y, x %d<=% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x >= y, x %d>=% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x < y, x %d<% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x > y, x %d>% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x == y, x %d==% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x != y, x %d!=% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x <= y, x %d<=% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x >= y, x %d>=% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x < y, x %d<% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x > y, x %d>% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x == y, x %d==% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x != y, x %d!=% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x <= y, x %d<=% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x >= y, x %d>=% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x < y, x %d<% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x > y, x %d>% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x == y, x %d==% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x != y, x %d!=% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x <= y, x %d<=% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x >= y, x %d>=% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x < y, x %d<% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x > y, x %d>% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x == y, x %d==% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x != y, x %d!=% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x <= y, x %d<=% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x >= y, x %d>=% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x < y, x %d<% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x > y, x %d>% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x == y, x %d==% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x != y, x %d!=% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x <= y, x %d<=% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x >= y, x %d>=% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x < y, x %d<% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x > y, x %d>% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x == y, x %d==% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x != y, x %d!=% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x <= y, x %d<=% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x >= y, x %d>=% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x < y, x %d<% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x > y, x %d>% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x == y, x %d==% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x != y, x %d!=% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x <= y, x %d<=% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x >= y, x %d>=% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x < y, x %d<% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x > y, x %d>% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x == y, x %d==% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x != y, x %d!=% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x <= y, x %d<=% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x >= y, x %d>=% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x < y, x %d<% y) 
----- PASSED      : test-decimal-eq.R<114--146>
 call| expect_equal(x > y, x %d>% y) 

test-decimal-eq.R.............   87 tests OK 0.3s

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

test-pro.R....................    0 tests    
test-pro.R....................    0 tests    
test-pro.R....................    1 tests OK 
test-pro.R....................    2 tests OK Loading required namespace: ggplot2

test-pro.R....................    6 tests OK 
test-pro.R....................    6 tests OK 
test-pro.R....................    6 tests OK 
test-pro.R....................    7 tests OK 
test-pro.R....................    7 tests OK 
test-pro.R....................    7 tests OK 
test-pro.R....................    8 tests OK 
test-pro.R....................    8 tests OK 
test-pro.R....................    8 tests OK 
test-pro.R....................    8 tests OK 
test-pro.R....................    9 tests OK 
test-pro.R....................    9 tests OK 
test-pro.R....................    9 tests OK 
test-pro.R....................   10 tests OK 
test-pro.R....................   10 tests OK 
test-pro.R....................   10 tests OK 
test-pro.R....................   11 tests OK 
test-pro.R....................   12 tests OK 
test-pro.R....................   13 tests OK 
test-pro.R....................   14 tests OK 0.5s

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 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..............   20 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..............   21 tests OK 0.6s

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

test-import_general.R.........    0 tests    
test-import_general.R.........    0 tests    
test-import_general.R.........    0 tests    
test-import_general.R.........    0 tests    
test-import_general.R.........    1 tests OK 
test-import_general.R.........    2 tests OK 
test-import_general.R.........    3 tests OK 
test-import_general.R.........    4 tests OK 
test-import_general.R.........    5 tests OK 
test-import_general.R.........    6 tests OK 
test-import_general.R.........    7 tests OK 
test-import_general.R.........    8 tests OK 
test-import_general.R.........    9 tests OK 
test-import_general.R.........    9 tests OK 
test-import_general.R.........    9 tests OK ----- PASSED      : test-import_general.R<55--89>
 call| expect_error(import_as(~stri., i), pattern = pattern) 
----- PASSED      : test-import_general.R<55--89>
 call| expect_error(import_inops(i), pattern = pattern) 
----- PASSED      : test-import_general.R<55--89>
 call| expect_error(import_inops(unexpose = i), pattern = pattern) 
----- PASSED      : test-import_general.R<55--89>
 call| expect_error(import_LL(i, "foo"), pattern = pattern) 
----- PASSED      : test-import_general.R<55--89>
 call| expect_error(pversion_check4mismatch(i), pattern = pattern) 
----- PASSED      : test-import_general.R<55--89>
 call| expect_error(pversion_report(i), pattern = pattern) 
----- PASSED      : test-import_general.R<55--89>
 call| expect_error(import_as(~stri., i), pattern = pattern) 
----- PASSED      : test-import_general.R<55--89>
 call| expect_error(import_inops(i), pattern = pattern) 
----- PASSED      : test-import_general.R<55--89>
 call| expect_error(import_inops(unexpose = i), pattern = pattern) 
----- PASSED      : test-import_general.R<55--89>
 call| expect_error(import_LL(i, "foo"), pattern = pattern) 
----- PASSED      : test-import_general.R<55--89>
 call| expect_error(pversion_check4mismatch(i), pattern = pattern) 
----- PASSED      : test-import_general.R<55--89>
 call| expect_error(pversion_report(i), pattern = pattern) 

test-import_general.R.........   25 tests OK 
test-import_general.R.........   26 tests OK 
test-import_general.R.........   27 tests OK 
test-import_general.R.........   28 tests OK 
test-import_general.R.........   28 tests OK 
test-import_general.R.........   28 tests OK 
test-import_general.R.........   28 tests OK ----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_as(~stri., i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_inops(i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_inops(unexpose = i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_LL(i, "foo"), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_int(form), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_as(~stri., i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_inops(i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_inops(unexpose = i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_LL(i, "foo"), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_int(form), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_as(~stri., i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_inops(i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_inops(unexpose = i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_LL(i, "foo"), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_int(form), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_as(~stri., i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_inops(i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_inops(unexpose = i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_LL(i, "foo"), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_int(form), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_as(~stri., i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_inops(i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_inops(unexpose = i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_LL(i, "foo"), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_int(form), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_as(~stri., i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_inops(i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_inops(unexpose = i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_LL(i, "foo"), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_int(form), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_as(~stri., i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_inops(i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_inops(unexpose = i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_LL(i, "foo"), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_int(form), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_as(~stri., i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_inops(i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_inops(unexpose = i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_LL(i, "foo"), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_int(form), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_as(~stri., i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_inops(i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_inops(unexpose = i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_LL(i, "foo"), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_int(form), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_as(~stri., i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_inops(i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_inops(unexpose = i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_LL(i, "foo"), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_int(form), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_as(~stri., i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_inops(i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_inops(unexpose = i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_LL(i, "foo"), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_int(form), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_as(~stri., i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_inops(i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_inops(unexpose = i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_LL(i, "foo"), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_int(form), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_as(~stri., i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_inops(i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_inops(unexpose = i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_LL(i, "foo"), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_int(form), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_as(~stri., i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_inops(i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_inops(unexpose = i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_LL(i, "foo"), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_int(form), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_as(~stri., i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_inops(i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_inops(unexpose = i), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_LL(i, "foo"), pattern = pattern) 
----- PASSED      : test-import_general.R<112--143>
 call| expect_error(import_int(form), pattern = pattern) 

test-import_general.R.........  133 tests OK 
test-import_general.R.........  134 tests OK 
test-import_general.R.........  135 tests OK 
test-import_general.R.........  135 tests OK 
test-import_general.R.........  135 tests OK 
test-import_general.R.........  135 tests OK ----- PASSED      : test-import_general.R<160--199>
 call| expect_error(import_as(~stri., i), pattern = pattern) 
----- PASSED      : test-import_general.R<160--199>
 call| expect_error(import_inops(i), pattern = pattern) 
----- PASSED      : test-import_general.R<160--199>
 call| expect_error(import_inops(unexpose = i), pattern = pattern) 
----- PASSED      : test-import_general.R<160--199>
 call| expect_error(import_LL(i, "foo"), pattern = pattern) 
----- PASSED      : test-import_general.R<160--199>
 call| expect_error(import_int(form), pattern = pattern) 
----- PASSED      : test-import_general.R<160--199>
 call| expect_error(pversion_check4mismatch(i), pattern = pattern) 
----- PASSED      : test-import_general.R<160--199>
 call| expect_error(pversion_report(i), pattern = pattern) 
----- PASSED      : test-import_general.R<160--199>
 call| expect_error(import_as(~stri., i), pattern = pattern) 
----- PASSED      : test-import_general.R<160--199>
 call| expect_error(import_inops(i), pattern = pattern) 
----- PASSED      : test-import_general.R<160--199>
 call| expect_error(import_inops(unexpose = i), pattern = pattern) 
----- PASSED      : test-import_general.R<160--199>
 call| expect_error(import_LL(i, "foo"), pattern = pattern) 
----- PASSED      : test-import_general.R<160--199>
 call| expect_error(import_int(form), pattern = pattern) 
----- PASSED      : test-import_general.R<160--199>
 call| expect_error(pversion_check4mismatch(i), pattern = pattern) 
----- PASSED      : test-import_general.R<160--199>
 call| expect_error(pversion_report(i), pattern = pattern) 
----- PASSED      : test-import_general.R<160--199>
 call| expect_error(import_as(~stri., i), pattern = pattern) 
----- PASSED      : test-import_general.R<160--199>
 call| expect_error(import_inops(i), pattern = pattern) 
----- PASSED      : test-import_general.R<160--199>
 call| expect_error(import_inops(unexpose = i), pattern = pattern) 
----- PASSED      : test-import_general.R<160--199>
 call| expect_error(import_LL(i, "foo"), pattern = pattern) 
----- PASSED      : test-import_general.R<160--199>
 call| expect_error(import_int(form), pattern = pattern) 
----- PASSED      : test-import_general.R<160--199>
 call| expect_error(pversion_check4mismatch(i), pattern = pattern) 
----- PASSED      : test-import_general.R<160--199>
 call| expect_error(pversion_report(i), pattern = pattern) 

test-import_general.R.........  162 tests OK 
test-import_general.R.........  163 tests OK 
test-import_general.R.........  164 tests OK 
test-import_general.R.........  165 tests OK 
test-import_general.R.........  166 tests OK 
test-import_general.R.........  167 tests OK 
test-import_general.R.........  168 tests OK 
test-import_general.R.........  169 tests OK 
test-import_general.R.........  170 tests OK 
test-import_general.R.........  171 tests OK 
test-import_general.R.........  172 tests OK 0.4s

test-import_inops-expose-alias.R    0 tests    
test-import_inops-expose-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-expose-alias.R    1 tests OK 
test-import_inops-expose-alias.R    1 tests OK 
test-import_inops-expose-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-expose-alias.R    2 tests OK 
test-import_inops-expose-alias.R    2 tests OK 
test-import_inops-expose-alias.R    2 tests OK 
test-import_inops-expose-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-expose-alias.R    3 tests OK 
test-import_inops-expose-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

test-import_inops-expose-alias.R    4 tests OK 
test-import_inops-expose-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.)` 


test-import_inops-expose-alias.R    5 tests OK 
test-import_inops-expose-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-expose-alias.R    6 tests OK 
test-import_inops-expose-alias.R    6 tests OK 
test-import_inops-expose-alias.R    7 tests OK 
test-import_inops-expose-alias.R    7 tests OK 
test-import_inops-expose-alias.R    8 tests OK 0.2s

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

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

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

test-import_inops-expose-pkg.R    3 tests OK 
test-import_inops-expose-pkg.R    3 tests OK Checking for conflicting infix operators in the current environment...
Placing infix operators in current environment...
Done

test-import_inops-expose-pkg.R    4 tests OK 
test-import_inops-expose-pkg.R    5 tests OK 
test-import_inops-expose-pkg.R    6 tests OK 
test-import_inops-expose-pkg.R    7 tests OK 
test-import_inops-expose-pkg.R    8 tests OK 
test-import_inops-expose-pkg.R    9 tests OK 
test-import_inops-expose-pkg.R   10 tests OK 
test-import_inops-expose-pkg.R   11 tests OK 
test-import_inops-expose-pkg.R   12 tests OK 
test-import_inops-expose-pkg.R   12 tests OK 
test-import_inops-expose-pkg.R   13 tests OK 62ms

test-import_inops-unexpose-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
Removing the following infix operators:
%s>=%, %stri<%, %s===%, %s==%, %stri*%, %stri===%, %stri>%, %s<=%, %stri+%, %s$%, %stri!=%, %stri>=%, %stri<=%, %s!==%, %stri$%, %s<%, %stri==%, %s!=%, %s*%, %stri!==%, %s>%, %s+%
Done

test-import_inops-unexpose-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.)` 


test-import_inops-unexpose-alias.R    1 tests OK No infix operators to unexpose

test-import_inops-unexpose-alias.R    2 tests OK No infix operators to unexpose

test-import_inops-unexpose-alias.R    3 tests OK 
test-import_inops-unexpose-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.)` 


test-import_inops-unexpose-alias.R    4 tests OK 
test-import_inops-unexpose-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.)` 


test-import_inops-unexpose-alias.R    5 tests OK 
test-import_inops-unexpose-alias.R    5 tests OK 
test-import_inops-unexpose-alias.R    6 tests OK 0.1s

test-import_inops-unexpose-pkg.R    0 tests    Checking for conflicting infix operators in the current environment...
Placing infix operators in current environment...
Done
Removing the following infix operators:
%s==%, %s<%, %s>=%, %stri!=%, %s>%, %s!=%, %stri<=%, %s$%, %stri<%, %stri*%, %stri!==%, %stri+%, %s!==%, %stri===%, %s*%, %s===%, %stri$%, %stri==%, %s+%, %s<=%, %stri>%, %stri>=%
Done

test-import_inops-unexpose-pkg.R    1 tests OK No infix operators to unexpose

test-import_inops-unexpose-pkg.R    2 tests OK No infix operators to unexpose

test-import_inops-unexpose-pkg.R    3 tests OK 
test-import_inops-unexpose-pkg.R    4 tests OK 
test-import_inops-unexpose-pkg.R    5 tests OK 
test-import_inops-unexpose-pkg.R    6 tests OK 38ms

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


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


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


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


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


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


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


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


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


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


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


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

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

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

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

test-import_inops.control.R...   13 tests OK 
test-import_inops.control.R...   13 tests OK 
test-import_inops.control.R...   14 tests OK 
test-import_inops.control.R...   14 tests OK 
test-import_inops.control.R...   15 tests OK 
test-import_inops.control.R...   15 tests OK 
test-import_inops.control.R...   16 tests OK 
test-import_inops.control.R...   16 tests OK 
test-import_inops.control.R...   17 tests OK 
test-import_inops.control.R...   17 tests OK 
test-import_inops.control.R...   18 tests OK 
test-import_inops.control.R...   18 tests OK 
test-import_inops.control.R...   19 tests OK 
test-import_inops.control.R...   19 tests OK 
test-import_inops.control.R...   20 tests OK 
test-import_inops.control.R...   20 tests OK 
test-import_inops.control.R...   21 tests OK 
test-import_inops.control.R...   21 tests OK 
test-import_inops.control.R...   22 tests OK 
test-import_inops.control.R...   22 tests OK 
test-import_inops.control.R...   23 tests OK 
test-import_inops.control.R...   23 tests OK 
test-import_inops.control.R...   24 tests OK 
test-import_inops.control.R...   24 tests OK 
test-import_inops.control.R...   25 tests OK 
test-import_inops.control.R...   25 tests OK 
test-import_inops.control.R...   26 tests OK 
test-import_inops.control.R...   26 tests OK Checking for conflicting infix operators in the current environment...
Placing infix operators in current environment...
Done
Checking for conflicting infix operators in the current environment...

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

test-import_inops.control.R...   28 tests OK 
test-import_inops.control.R...   28 tests OK 
test-import_inops.control.R...   29 tests OK 
test-import_inops.control.R...   29 tests OK 
test-import_inops.control.R...   30 tests OK 0.4s

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

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 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 
test-internal.R...............    5 tests OK 
test-internal.R...............    5 tests OK 
test-internal.R...............    5 tests OK 
test-internal.R...............    5 tests OK 
test-internal.R...............    5 tests OK 
test-internal.R...............    5 tests OK 
test-internal.R...............    5 tests OK 
test-internal.R...............    5 tests OK 
test-internal.R...............    5 tests OK 
test-internal.R...............    5 tests OK 
test-internal.R...............    5 tests OK 
test-internal.R...............    6 tests OK 4ms

test-libs.R...................    0 tests    
test-libs.R...................    0 tests    
test-libs.R...................    1 tests OK 63ms

test-pkgs.R...................    1 tests OK 
test-pkgs.R...................    2 tests OK 
test-pkgs.R...................    3 tests OK 
test-pkgs.R...................    4 tests OK 
test-pkgs.R...................    4 tests OK 
test-pkgs.R...................    4 tests OK 
test-pkgs.R...................    4 tests OK 
test-pkgs.R...................    4 tests OK 
test-pkgs.R...................    4 tests OK 
test-pkgs.R...................    4 tests OK 
test-pkgs.R...................    5 tests OK 
test-pkgs.R...................    5 tests OK 
test-pkgs.R...................    5 tests OK 
test-pkgs.R...................    6 tests OK 
test-pkgs.R...................    6 tests OK 
test-pkgs.R...................    6 tests OK 
test-pkgs.R...................    7 tests OK 
test-pkgs.R...................    8 tests OK 
test-pkgs.R...................    9 tests OK 
test-pkgs.R...................   10 tests OK 
test-pkgs.R...................   11 tests OK 26ms

test-pversion.R...............    1 tests OK 
test-pversion.R...............    1 tests OK 
test-pversion.R...............    2 tests OK 
test-pversion.R...............    3 tests OK 
test-pversion.R...............    4 tests OK 
test-pversion.R...............    5 tests OK 21ms
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 
test-x.import.R...............   14 tests OK 
test-x.import.R...............   14 tests OK 
test-x.import.R...............   15 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-x.import.R...............   15 tests OK 
test-x.import.R...............   16 tests OK 
test-x.import.R...............   17 tests OK 
test-x.import.R...............   17 tests OK 
test-x.import.R...............   18 tests OK 
test-x.import.R...............   19 tests OK 
test-x.import.R...............   19 tests OK 
test-x.import.R...............   19 tests OK 
test-x.import.R...............   20 tests OK 
test-x.import.R...............   21 tests OK 
test-x.import.R...............   21 tests OK 
test-x.import.R...............   22 tests OK 
test-x.import.R...............   22 tests OK 
test-x.import.R...............   23 tests OK 
test-x.import.R...............   23 tests OK Checking for conflicting infix operators in the current environment...
Placing infix operators in current environment...
Done

test-x.import.R...............   24 tests OK 
test-x.import.R...............   24 tests OK Checking for conflicting infix operators in the current environment...
Placing infix operators in current environment...
Done

test-x.import.R...............   25 tests OK 
test-x.import.R...............   25 tests OK Checking for conflicting infix operators in the current environment...
Placing infix operators in current environment...
Done

test-x.import.R...............   26 tests OK 
test-x.import.R...............   26 tests OK Checking for conflicting infix operators in the current environment...
Placing infix operators in current environment...
Done

test-x.import.R...............   27 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-x.import.R...............   27 tests OK 
test-x.import.R...............   27 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-x.import.R...............   28 tests OK 
test-x.import.R...............   28 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-x.import.R...............   29 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-x.import.R...............   29 tests OK 
test-x.import.R...............   29 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-x.import.R...............   30 tests OK 
test-x.import.R...............   30 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-x.import.R...............   31 tests OK 
test-x.import.R...............   31 tests OK exposing and locking functions to current environment ...
Done

test-x.import.R...............   32 tests OK 
test-x.import.R...............   32 tests OK 
test-x.import.R...............   33 tests OK 
test-x.import.R...............   33 tests OK 
test-x.import.R...............   34 tests OK 0.2s

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

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

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

test-str_search.R.............    0 tests    
test-str_search.R.............    0 tests    
test-str_search.R.............    0 tests    
test-str_search.R.............    0 tests    
test-str_search.R.............    0 tests    
test-str_search.R.............    0 tests    ----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search.R<32--57>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], case_insensitive = iCI), 
 call| -->    stringi::stri_detect(x[[iX]], fixed = pattern[[iP]], case_insensitive = iCI, 
 call| -->        negate = TRUE)) 

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

test-str_search_at.R..........    0 tests    
test-str_search_at.R..........    0 tests    
test-str_search_at.R..........    0 tests    
test-str_search_at.R..........    0 tests    
test-str_search_at.R..........    0 tests    
test-str_search_at.R..........    0 tests    ----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_fixed(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "start", 
 call| -->    case_insensitive = iCI), stringi::stri_startswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-str_search_at.R<31--72>
 call| expect_equal(x[[iX]] %s!{}% s_regex(pattern[[iP]], at = "end", 
 call| -->    case_insensitive = iCI), stringi::stri_endswith(x[[iX]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI, negate = TRUE)) 

test-str_search_at.R..........  672 tests OK 
test-str_search_at.R..........  672 tests OK 
test-str_search_at.R..........  672 tests OK 
test-str_search_at.R..........  673 tests OK 
test-str_search_at.R..........  673 tests OK 
test-str_search_at.R..........  674 tests OK 
test-str_search_at.R..........  674 tests OK 
test-str_search_at.R..........  675 tests OK 
test-str_search_at.R..........  675 tests OK 
test-str_search_at.R..........  676 tests OK 
test-str_search_at.R..........  677 tests OK 
test-str_search_at.R..........  678 tests OK 
test-str_search_at.R..........  679 tests OK 
test-str_search_at.R..........  680 tests OK 7.6s

test-str_subset_ops.R.........    0 tests    
test-str_subset_ops.R.........    0 tests    
test-str_subset_ops.R.........    0 tests    
test-str_subset_ops.R.........    0 tests    [1] "abcdefghijklm" "nopqrstuvwxyz" "abcdefghijklm" "nopqrstuvwxyz"
[5] "abcdefghijklm" "nopqrstuvwxyz" "abcdefghijklm"

test-str_subset_ops.R.........    0 tests    
test-str_subset_ops.R.........    0 tests    
test-str_subset_ops.R.........    1 tests OK 
test-str_subset_ops.R.........    1 tests OK 
test-str_subset_ops.R.........    1 tests OK 
test-str_subset_ops.R.........    1 tests OK 
test-str_subset_ops.R.........    1 tests OK 
test-str_subset_ops.R.........    2 tests OK 
test-str_subset_ops.R.........    3 tests OK 
test-str_subset_ops.R.........    3 tests OK 
test-str_subset_ops.R.........    3 tests OK 
test-str_subset_ops.R.........    3 tests OK 
test-str_subset_ops.R.........    4 tests OK 
test-str_subset_ops.R.........    4 tests OK [1] "abcdefghijklm" "nopqrstuvwxyz" "abcdefghijklm" "nopqrstuvwxyz"

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

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

test-strfind_extract.R........    0 tests    
test-strfind_extract.R........    0 tests    
test-strfind_extract.R........    0 tests    
test-strfind_extract.R........    0 tests    
test-strfind_extract.R........    0 tests    
test-strfind_extract.R........    0 tests    
test-strfind_extract.R........    0 tests    
test-strfind_extract.R........    1 tests OK 
test-strfind_extract.R........    2 tests OK 
test-strfind_extract.R........    2 tests OK [1] "abcdefghijklm" "nopqrstuvwxyz" "ABCDEFGHIJKLM" "NOPQRSTUVWXYZ"

test-strfind_extract.R........    2 tests OK 
test-strfind_extract.R........    2 tests OK 
test-strfind_extract.R........    2 tests OK 
test-strfind_extract.R........    3 tests OK 
test-strfind_extract.R........    4 tests OK 
test-strfind_extract.R........    4 tests OK 
test-strfind_extract.R........    4 tests OK 
test-strfind_extract.R........    5 tests OK 
test-strfind_extract.R........    5 tests OK 
test-strfind_extract.R........    5 tests OK 
test-strfind_extract.R........    5 tests OK 
test-strfind_extract.R........    6 tests OK 
test-strfind_extract.R........    6 tests OK 
test-strfind_extract.R........    6 tests OK 
test-strfind_extract.R........    6 tests OK 
test-strfind_extract.R........    7 tests OK 8ms

test-strfind_locate_all.R.....    0 tests    
test-strfind_locate_all.R.....    0 tests    
test-strfind_locate_all.R.....    0 tests    
test-strfind_locate_all.R.....    0 tests    
test-strfind_locate_all.R.....    0 tests    
test-strfind_locate_all.R.....    0 tests    
test-strfind_locate_all.R.....    0 tests    
test-strfind_locate_all.R.....    1 tests OK 
test-strfind_locate_all.R.....    2 tests OK 
test-strfind_locate_all.R.....    2 tests OK [1] "abcdefghijklm" "nopqrstuvwxyz" "ABCDEFGHIJKLM" "NOPQRSTUVWXYZ"

test-strfind_locate_all.R.....    2 tests OK 
test-strfind_locate_all.R.....    2 tests OK 
test-strfind_locate_all.R.....    2 tests OK 
test-strfind_locate_all.R.....    3 tests OK 
test-strfind_locate_all.R.....    4 tests OK 
test-strfind_locate_all.R.....    4 tests OK 
test-strfind_locate_all.R.....    4 tests OK 
test-strfind_locate_all.R.....    5 tests OK 
test-strfind_locate_all.R.....    5 tests OK 
test-strfind_locate_all.R.....    5 tests OK 
test-strfind_locate_all.R.....    5 tests OK 
test-strfind_locate_all.R.....    6 tests OK 
test-strfind_locate_all.R.....    6 tests OK 
test-strfind_locate_all.R.....    6 tests OK 
test-strfind_locate_all.R.....    6 tests OK 
test-strfind_locate_all.R.....    7 tests OK 10ms

test-strfind_locate_ith.R.....    0 tests    
test-strfind_locate_ith.R.....    0 tests    
test-strfind_locate_ith.R.....    0 tests    
test-strfind_locate_ith.R.....    0 tests     [1] "0123456789" "0123456789" "0123456789" "0123456789" "0123456789"
 [6] "0123456789" "0123456789" "0123456789" "0123456789" "0123456789"

test-strfind_locate_ith.R.....    0 tests    
test-strfind_locate_ith.R.....    0 tests    
test-strfind_locate_ith.R.....    0 tests    
test-strfind_locate_ith.R.....    0 tests    
test-strfind_locate_ith.R.....    0 tests    
test-strfind_locate_ith.R.....    0 tests    
test-strfind_locate_ith.R.....    0 tests    
test-strfind_locate_ith.R.....    1 tests OK 
test-strfind_locate_ith.R.....    1 tests OK  [1] "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa"
 [6] "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa"

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

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

test-strfind_locate_ith.R.....    4 tests OK 
test-strfind_locate_ith.R.....    4 tests OK 
test-strfind_locate_ith.R.....    4 tests OK 
test-strfind_locate_ith.R.....    4 tests OK 
test-strfind_locate_ith.R.....    4 tests OK 
test-strfind_locate_ith.R.....    4 tests OK 
test-strfind_locate_ith.R.....    4 tests OK 
test-strfind_locate_ith.R.....    5 tests OK 
test-strfind_locate_ith.R.....    5 tests OK 
test-strfind_locate_ith.R.....    5 tests OK 
test-strfind_locate_ith.R.....    5 tests OK 
test-strfind_locate_ith.R.....    5 tests OK 
test-strfind_locate_ith.R.....    5 tests OK 
test-strfind_locate_ith.R.....    6 tests OK 
test-strfind_locate_ith.R.....    7 tests OK 
test-strfind_locate_ith.R.....    7 tests OK 
test-strfind_locate_ith.R.....    8 tests OK 
test-strfind_locate_ith.R.....    8 tests OK 
test-strfind_locate_ith.R.....    8 tests OK 
test-strfind_locate_ith.R.....    8 tests OK 
test-strfind_locate_ith.R.....    8 tests OK 
test-strfind_locate_ith.R.....    8 tests OK 
test-strfind_locate_ith.R.....    9 tests OK 
test-strfind_locate_ith.R.....    9 tests OK 
test-strfind_locate_ith.R.....   10 tests OK 
test-strfind_locate_ith.R.....   10 tests OK 
test-strfind_locate_ith.R.....   10 tests OK 
test-strfind_locate_ith.R.....   10 tests OK 
test-strfind_locate_ith.R.....   10 tests OK 
test-strfind_locate_ith.R.....   10 tests OK 
test-strfind_locate_ith.R.....   11 tests OK 
test-strfind_locate_ith.R.....   11 tests OK 
test-strfind_locate_ith.R.....   12 tests OK 15ms

test-strfind_replace.R........    0 tests    
test-strfind_replace.R........    0 tests    
test-strfind_replace.R........    0 tests    
test-strfind_replace.R........    0 tests    
test-strfind_replace.R........    0 tests    
test-strfind_replace.R........    0 tests    
test-strfind_replace.R........    0 tests    
test-strfind_replace.R........    0 tests    ----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<42--65>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 

test-strfind_replace.R........  720 tests OK 
test-strfind_replace.R........  720 tests OK 
test-strfind_replace.R........  720 tests OK 
test-strfind_replace.R........  720 tests OK 
test-strfind_replace.R........  720 tests OK 
test-strfind_replace.R........  721 tests OK 
test-strfind_replace.R........  722 tests OK 
test-strfind_replace.R........  722 tests OK [1] "abcdefghijklm" "nopqrstuvwxyz" "ABCDEFGHIJKLM" "NOPQRSTUVWXYZ"

test-strfind_replace.R........  722 tests OK 
test-strfind_replace.R........  722 tests OK 
test-strfind_replace.R........  722 tests OK 
test-strfind_replace.R........  723 tests OK 
test-strfind_replace.R........  724 tests OK 
test-strfind_replace.R........  724 tests OK 
test-strfind_replace.R........  724 tests OK 
test-strfind_replace.R........  725 tests OK 
test-strfind_replace.R........  725 tests OK 
test-strfind_replace.R........  725 tests OK 
test-strfind_replace.R........  725 tests OK 
test-strfind_replace.R........  726 tests OK 
test-strfind_replace.R........  726 tests OK 
test-strfind_replace.R........  726 tests OK 
test-strfind_replace.R........  726 tests OK 
test-strfind_replace.R........  726 tests OK 
test-strfind_replace.R........  726 tests OK ----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<131--154>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 

test-strfind_replace.R........ 1446 tests OK 
test-strfind_replace.R........ 1446 tests OK 
test-strfind_replace.R........ 1446 tests OK 
test-strfind_replace.R........ 1446 tests OK 
test-strfind_replace.R........ 1446 tests OK 
test-strfind_replace.R........ 1447 tests OK 
test-strfind_replace.R........ 1448 tests OK 
test-strfind_replace.R........ 1448 tests OK [1] "abcdefghijklm" "nopqrstuvwxyz" "ABCDEFGHIJKLM" "NOPQRSTUVWXYZ"

test-strfind_replace.R........ 1448 tests OK 
test-strfind_replace.R........ 1448 tests OK 
test-strfind_replace.R........ 1448 tests OK 
test-strfind_replace.R........ 1449 tests OK 
test-strfind_replace.R........ 1450 tests OK 
test-strfind_replace.R........ 1450 tests OK 
test-strfind_replace.R........ 1450 tests OK 
test-strfind_replace.R........ 1451 tests OK 
test-strfind_replace.R........ 1451 tests OK 
test-strfind_replace.R........ 1451 tests OK 
test-strfind_replace.R........ 1451 tests OK 
test-strfind_replace.R........ 1452 tests OK 
test-strfind_replace.R........ 1452 tests OK 
test-strfind_replace.R........ 1452 tests OK 
test-strfind_replace.R........ 1452 tests OK 
test-strfind_replace.R........ 1452 tests OK 
test-strfind_replace.R........ 1452 tests OK 
test-strfind_replace.R........ 1453 tests OK 
test-strfind_replace.R........ 1453 tests OK 
test-strfind_replace.R........ 1453 tests OK 
test-strfind_replace.R........ 1453 tests OK 
test-strfind_replace.R........ 1453 tests OK 
test-strfind_replace.R........ 1454 tests OK 
test-strfind_replace.R........ 1455 tests OK 
test-strfind_replace.R........ 1455 tests OK [1] "abcdefghijklm" "nopqrstuvwxyz" "ABCDEFGHIJKLM" "NOPQRSTUVWXYZ"

test-strfind_replace.R........ 1455 tests OK 
test-strfind_replace.R........ 1455 tests OK 
test-strfind_replace.R........ 1455 tests OK 
test-strfind_replace.R........ 1456 tests OK 
test-strfind_replace.R........ 1457 tests OK 
test-strfind_replace.R........ 1457 tests OK 
test-strfind_replace.R........ 1457 tests OK 
test-strfind_replace.R........ 1458 tests OK 
test-strfind_replace.R........ 1458 tests OK 
test-strfind_replace.R........ 1458 tests OK 
test-strfind_replace.R........ 1458 tests OK 
test-strfind_replace.R........ 1459 tests OK 
test-strfind_replace.R........ 1459 tests OK 
test-strfind_replace.R........ 1459 tests OK 
test-strfind_replace.R........ 1459 tests OK 
test-strfind_replace.R........ 1459 tests OK 
test-strfind_replace.R........ 1459 tests OK ----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<268--291>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 

test-strfind_replace.R........ 2179 tests OK 
test-strfind_replace.R........ 2179 tests OK 
test-strfind_replace.R........ 2179 tests OK 
test-strfind_replace.R........ 2179 tests OK 
test-strfind_replace.R........ 2179 tests OK 
test-strfind_replace.R........ 2180 tests OK 
test-strfind_replace.R........ 2181 tests OK 
test-strfind_replace.R........ 2181 tests OK [1] "abcdefghijklm" "nopqrstuvwxyz" "ABCDEFGHIJKLM" "NOPQRSTUVWXYZ"

test-strfind_replace.R........ 2181 tests OK 
test-strfind_replace.R........ 2181 tests OK 
test-strfind_replace.R........ 2181 tests OK 
test-strfind_replace.R........ 2182 tests OK 
test-strfind_replace.R........ 2183 tests OK 
test-strfind_replace.R........ 2183 tests OK 
test-strfind_replace.R........ 2183 tests OK 
test-strfind_replace.R........ 2184 tests OK 
test-strfind_replace.R........ 2184 tests OK 
test-strfind_replace.R........ 2184 tests OK 
test-strfind_replace.R........ 2184 tests OK 
test-strfind_replace.R........ 2185 tests OK 
test-strfind_replace.R........ 2185 tests OK 
test-strfind_replace.R........ 2185 tests OK 
test-strfind_replace.R........ 2185 tests OK 
test-strfind_replace.R........ 2185 tests OK 
test-strfind_replace.R........ 2185 tests OK ----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    fixed = pattern[[iP]], case_insensitive = iCI)) 
----- PASSED      : test-strfind_replace.R<356--379>
 call| expect_equal(out, stringi::stri_replace_all(x[[iX]], rp[[iRp]], 
 call| -->    regex = pattern[[iP]], case_insensitive = iCI)) 

test-strfind_replace.R........ 2905 tests OK 
test-strfind_replace.R........ 2905 tests OK 
test-strfind_replace.R........ 2905 tests OK 
test-strfind_replace.R........ 2905 tests OK 
test-strfind_replace.R........ 2905 tests OK 
test-strfind_replace.R........ 2906 tests OK 
test-strfind_replace.R........ 2907 tests OK 
test-strfind_replace.R........ 2907 tests OK [1] "abcdefghijklm" "nopqrstuvwxyz" "ABCDEFGHIJKLM" "NOPQRSTUVWXYZ"

test-strfind_replace.R........ 2907 tests OK 
test-strfind_replace.R........ 2907 tests OK 
test-strfind_replace.R........ 2907 tests OK 
test-strfind_replace.R........ 2908 tests OK 
test-strfind_replace.R........ 2909 tests OK 
test-strfind_replace.R........ 2909 tests OK 
test-strfind_replace.R........ 2909 tests OK 
test-strfind_replace.R........ 2910 tests OK 
test-strfind_replace.R........ 2910 tests OK 
test-strfind_replace.R........ 2910 tests OK 
test-strfind_replace.R........ 2910 tests OK 
test-strfind_replace.R........ 2911 tests OK 17.4s

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    
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........    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 ----- PASSED      : test-stri_locate_ith.R<22--38>
 call| expect_equal(tonyfirst, strifirst) 
----- PASSED      : test-stri_locate_ith.R<22--38>
 call| expect_equal(tonylast, strilast) 
----- PASSED      : test-stri_locate_ith.R<22--38>
 call| expect_equal(tonyfirst, strifirst) 
----- PASSED      : test-stri_locate_ith.R<22--38>
 call| expect_equal(tonylast, strilast) 
----- PASSED      : test-stri_locate_ith.R<22--38>
 call| expect_equal(tonyfirst, strifirst) 
----- PASSED      : test-stri_locate_ith.R<22--38>
 call| expect_equal(tonylast, strilast) 
----- PASSED      : test-stri_locate_ith.R<22--38>
 call| expect_equal(tonyfirst, strifirst) 
----- PASSED      : test-stri_locate_ith.R<22--38>
 call| expect_equal(tonylast, strilast) 

test-stri_locate_ith.R........   10 tests OK 
test-stri_locate_ith.R........   10 tests OK 
test-stri_locate_ith.R........   10 tests OK 
test-stri_locate_ith.R........   10 tests OK 
test-stri_locate_ith.R........   10 tests OK 
test-stri_locate_ith.R........   10 tests OK 
test-stri_locate_ith.R........   10 tests OK 
test-stri_locate_ith.R........   11 tests OK 
test-stri_locate_ith.R........   12 tests OK 
test-stri_locate_ith.R........   13 tests OK 
test-stri_locate_ith.R........   13 tests OK [1] "abcdefghijklm" "nopqrstuvwxyz"

test-stri_locate_ith.R........   13 tests OK 
test-stri_locate_ith.R........   13 tests OK 
test-stri_locate_ith.R........   13 tests OK 
test-stri_locate_ith.R........   14 tests OK 
test-stri_locate_ith.R........   14 tests OK 
test-stri_locate_ith.R........   14 tests OK 
test-stri_locate_ith.R........   14 tests OK ----- PASSED      : test-stri_locate_ith.R<72--88>
 call| expect_equal(tonyfirst, strifirst) 
----- PASSED      : test-stri_locate_ith.R<72--88>
 call| expect_equal(tonylast, strilast) 
----- PASSED      : test-stri_locate_ith.R<72--88>
 call| expect_equal(tonyfirst, strifirst) 
----- PASSED      : test-stri_locate_ith.R<72--88>
 call| expect_equal(tonylast, strilast) 
----- PASSED      : test-stri_locate_ith.R<72--88>
 call| expect_equal(tonyfirst, strifirst) 
----- PASSED      : test-stri_locate_ith.R<72--88>
 call| expect_equal(tonylast, strilast) 
----- PASSED      : test-stri_locate_ith.R<72--88>
 call| expect_equal(tonyfirst, strifirst) 
----- PASSED      : test-stri_locate_ith.R<72--88>
 call| expect_equal(tonylast, strilast) 

test-stri_locate_ith.R........   22 tests OK 
test-stri_locate_ith.R........   22 tests OK 
test-stri_locate_ith.R........   22 tests OK 
test-stri_locate_ith.R........   22 tests OK 
test-stri_locate_ith.R........   22 tests OK 
test-stri_locate_ith.R........   22 tests OK 
test-stri_locate_ith.R........   22 tests OK 
test-stri_locate_ith.R........   23 tests OK 
test-stri_locate_ith.R........   24 tests OK 
test-stri_locate_ith.R........   25 tests OK 
test-stri_locate_ith.R........   25 tests OK 
test-stri_locate_ith.R........   25 tests OK 
test-stri_locate_ith.R........   25 tests OK 
test-stri_locate_ith.R........   26 tests OK 
test-stri_locate_ith.R........   27 tests OK 
test-stri_locate_ith.R........   27 tests OK 
test-stri_locate_ith.R........   27 tests OK 
test-stri_locate_ith.R........   27 tests OK 
test-stri_locate_ith.R........   27 tests OK 
test-stri_locate_ith.R........   27 tests OK 
test-stri_locate_ith.R........   27 tests OK 
test-stri_locate_ith.R........   27 tests OK 
test-stri_locate_ith.R........   28 tests OK 
test-stri_locate_ith.R........   29 tests OK 
test-stri_locate_ith.R........   29 tests OK 
test-stri_locate_ith.R........   29 tests OK 
test-stri_locate_ith.R........   29 tests OK 
test-stri_locate_ith.R........   29 tests OK 
test-stri_locate_ith.R........   29 tests OK 
test-stri_locate_ith.R........   29 tests OK 
test-stri_locate_ith.R........   29 tests OK 
test-stri_locate_ith.R........   30 tests OK 
test-stri_locate_ith.R........   31 tests OK 
test-stri_locate_ith.R........   32 tests OK 
test-stri_locate_ith.R........   32 tests OK 
test-stri_locate_ith.R........   32 tests OK 
test-stri_locate_ith.R........   32 tests OK 
test-stri_locate_ith.R........   33 tests OK 
test-stri_locate_ith.R........   34 tests OK 
test-stri_locate_ith.R........   35 tests OK 
test-stri_locate_ith.R........   35 tests OK 
test-stri_locate_ith.R........   35 tests OK 
test-stri_locate_ith.R........   35 tests OK 
test-stri_locate_ith.R........   35 tests OK 
test-stri_locate_ith.R........   35 tests OK 
test-stri_locate_ith.R........   35 tests OK 
test-stri_locate_ith.R........   36 tests OK 
test-stri_locate_ith.R........   37 tests OK 
test-stri_locate_ith.R........   38 tests OK 
test-stri_locate_ith.R........   38 tests OK 
test-stri_locate_ith.R........   38 tests OK 
test-stri_locate_ith.R........   39 tests OK 
test-stri_locate_ith.R........   40 tests OK 
test-stri_locate_ith.R........   41 tests OK 
test-stri_locate_ith.R........   41 tests OK 
test-stri_locate_ith.R........   41 tests OK 
test-stri_locate_ith.R........   41 tests OK 
test-stri_locate_ith.R........   41 tests OK 
test-stri_locate_ith.R........   41 tests OK 
test-stri_locate_ith.R........   42 tests OK 
test-stri_locate_ith.R........   43 tests OK 
test-stri_locate_ith.R........   44 tests OK 65ms

test-stri_locate_ith_general.R    0 tests    
test-stri_locate_ith_general.R    0 tests    
test-stri_locate_ith_general.R    0 tests    
test-stri_locate_ith_general.R    0 tests     [1] "0123456789" "0123456789" "0123456789" "0123456789" "0123456789"
 [6] "0123456789" "0123456789" "0123456789" "0123456789" "0123456789"

test-stri_locate_ith_general.R    0 tests    
test-stri_locate_ith_general.R    0 tests    
test-stri_locate_ith_general.R    0 tests    
test-stri_locate_ith_general.R    0 tests    
test-stri_locate_ith_general.R    0 tests    
test-stri_locate_ith_general.R    0 tests    
test-stri_locate_ith_general.R    1 tests OK 
test-stri_locate_ith_general.R    1 tests OK  [1] "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa"
 [6] "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa" "aaaaaaaaaa"

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

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

test-stri_locate_ith_general.R    4 tests OK 
test-stri_locate_ith_general.R    4 tests OK 
test-stri_locate_ith_general.R    4 tests OK 
test-stri_locate_ith_general.R    4 tests OK 
test-stri_locate_ith_general.R    4 tests OK 
test-stri_locate_ith_general.R    4 tests OK 
test-stri_locate_ith_general.R    5 tests OK 
test-stri_locate_ith_general.R    5 tests OK 
test-stri_locate_ith_general.R    5 tests OK 
test-stri_locate_ith_general.R    5 tests OK 
test-stri_locate_ith_general.R    5 tests OK 
test-stri_locate_ith_general.R    5 tests OK 
test-stri_locate_ith_general.R    5 tests OK 
test-stri_locate_ith_general.R    5 tests OK 
test-stri_locate_ith_general.R    5 tests OK 
test-stri_locate_ith_general.R    6 tests OK 
test-stri_locate_ith_general.R    6 tests OK 
test-stri_locate_ith_general.R    6 tests OK 
test-stri_locate_ith_general.R    6 tests OK [1] "0123456789"

test-stri_locate_ith_general.R    6 tests OK 
test-stri_locate_ith_general.R    6 tests OK 
test-stri_locate_ith_general.R    6 tests OK 
test-stri_locate_ith_general.R    6 tests OK 
test-stri_locate_ith_general.R    6 tests OK 
test-stri_locate_ith_general.R    6 tests OK 
test-stri_locate_ith_general.R    7 tests OK 
test-stri_locate_ith_general.R    7 tests OK [1] "aaaaaaaaaa"

test-stri_locate_ith_general.R    7 tests OK 
test-stri_locate_ith_general.R    7 tests OK 
test-stri_locate_ith_general.R    7 tests OK 
test-stri_locate_ith_general.R    7 tests OK 
test-stri_locate_ith_general.R    7 tests OK 
test-stri_locate_ith_general.R    7 tests OK 
test-stri_locate_ith_general.R    8 tests OK 
test-stri_locate_ith_general.R    8 tests OK [1] "ýýýýýýýýýý"

test-stri_locate_ith_general.R    8 tests OK 
test-stri_locate_ith_general.R    8 tests OK 
test-stri_locate_ith_general.R    8 tests OK 
test-stri_locate_ith_general.R    8 tests OK 
test-stri_locate_ith_general.R    8 tests OK 
test-stri_locate_ith_general.R    8 tests OK 
test-stri_locate_ith_general.R    9 tests OK 
test-stri_locate_ith_general.R    9 tests OK [1] "a a a a a a a a a a"

test-stri_locate_ith_general.R    9 tests OK 
test-stri_locate_ith_general.R    9 tests OK 
test-stri_locate_ith_general.R    9 tests OK 
test-stri_locate_ith_general.R    9 tests OK 
test-stri_locate_ith_general.R    9 tests OK 
test-stri_locate_ith_general.R    9 tests OK 
test-stri_locate_ith_general.R   10 tests OK 
test-stri_locate_ith_general.R   10 tests OK [1] "aaaaaaaaaa"

test-stri_locate_ith_general.R   10 tests OK 
test-stri_locate_ith_general.R   10 tests OK 
test-stri_locate_ith_general.R   10 tests OK 
test-stri_locate_ith_general.R   10 tests OK 
test-stri_locate_ith_general.R   10 tests OK 
test-stri_locate_ith_general.R   10 tests OK 
test-stri_locate_ith_general.R   11 tests OK 
test-stri_locate_ith_general.R   11 tests OK 
test-stri_locate_ith_general.R   11 tests OK 
test-stri_locate_ith_general.R   11 tests OK 
test-stri_locate_ith_general.R   11 tests OK 
test-stri_locate_ith_general.R   11 tests OK 
test-stri_locate_ith_general.R   11 tests OK 
test-stri_locate_ith_general.R   11 tests OK 
test-stri_locate_ith_general.R   12 tests OK 
test-stri_locate_ith_general.R   12 tests OK 
test-stri_locate_ith_general.R   12 tests OK 
test-stri_locate_ith_general.R   12 tests OK 
test-stri_locate_ith_general.R   12 tests OK 
test-stri_locate_ith_general.R   13 tests OK 
test-stri_locate_ith_general.R   14 tests OK 
test-stri_locate_ith_general.R   14 tests OK 
test-stri_locate_ith_general.R   15 tests OK 
test-stri_locate_ith_general.R   16 tests OK 
test-stri_locate_ith_general.R   17 tests OK 
test-stri_locate_ith_general.R   17 tests OK 
test-stri_locate_ith_general.R   17 tests OK 
test-stri_locate_ith_general.R   17 tests OK 
test-stri_locate_ith_general.R   17 tests OK 
test-stri_locate_ith_general.R   18 tests OK 
test-stri_locate_ith_general.R   19 tests OK 
test-stri_locate_ith_general.R   19 tests OK 
test-stri_locate_ith_general.R   20 tests OK 
test-stri_locate_ith_general.R   21 tests OK 
test-stri_locate_ith_general.R   22 tests OK 
test-stri_locate_ith_general.R   22 tests OK 
test-stri_locate_ith_general.R   22 tests OK 
test-stri_locate_ith_general.R   22 tests OK 
test-stri_locate_ith_general.R   22 tests OK 
test-stri_locate_ith_general.R   23 tests OK 
test-stri_locate_ith_general.R   24 tests OK 
test-stri_locate_ith_general.R   24 tests OK 
test-stri_locate_ith_general.R   25 tests OK 
test-stri_locate_ith_general.R   26 tests OK 
test-stri_locate_ith_general.R   27 tests OK 
test-stri_locate_ith_general.R   27 tests OK 
test-stri_locate_ith_general.R   27 tests OK 
test-stri_locate_ith_general.R   27 tests OK 
test-stri_locate_ith_general.R   27 tests OK 
test-stri_locate_ith_general.R   28 tests OK 
test-stri_locate_ith_general.R   28 tests OK 
test-stri_locate_ith_general.R   29 tests OK 
test-stri_locate_ith_general.R   30 tests OK 
test-stri_locate_ith_general.R   31 tests OK 
test-stri_locate_ith_general.R   31 tests OK 
test-stri_locate_ith_general.R   31 tests OK 
test-stri_locate_ith_general.R   31 tests OK iX =  1 ; iP =  1 ; iCI =  TRUE 
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = 1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = -1, 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = 1), 
 call| -->    stringi::stri_locate_first(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, first"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = -1), 
 call| -->    stringi::stri_locate_last(x[[iX]], coll = pattern[[iP]])) 
[1] "Done: coll, last"
----- PASSED      : test-stri_locate_ith_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R<276--341>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = 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_general.R  431 tests OK 
test-stri_locate_ith_general.R  431 tests OK 
test-stri_locate_ith_general.R  431 tests OK 
test-stri_locate_ith_general.R  431 tests OK iX =  1 ; iP =  1 ; iCI =  TRUE 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = c(1, -1), case_insensitive = iCI), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = c(1, -1), case_insensitive = iCI), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = c(1, 
 call| -->    -1)), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = stringi::stri_c("[", 
 call| -->    pattern[[iP]], "]"), i = c(1, -1), merge = FALSE), expected) 
iX =  1 ; iP =  1 ; iCI =  FALSE 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = c(1, -1), case_insensitive = iCI), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = c(1, -1), case_insensitive = iCI), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = c(1, 
 call| -->    -1)), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = stringi::stri_c("[", 
 call| -->    pattern[[iP]], "]"), i = c(1, -1), merge = FALSE), expected) 
iX =  1 ; iP =  2 ; iCI =  TRUE 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = c(1, -1), case_insensitive = iCI), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = c(1, -1), case_insensitive = iCI), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = c(1, 
 call| -->    -1)), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = stringi::stri_c("[", 
 call| -->    pattern[[iP]], "]"), i = c(1, -1), merge = FALSE), expected) 
iX =  1 ; iP =  2 ; iCI =  FALSE 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = c(1, -1), case_insensitive = iCI), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = c(1, -1), case_insensitive = iCI), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = c(1, 
 call| -->    -1)), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = stringi::stri_c("[", 
 call| -->    pattern[[iP]], "]"), i = c(1, -1), merge = FALSE), expected) 
iX =  1 ; iP =  3 ; iCI =  TRUE 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = c(1, -1), case_insensitive = iCI), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = c(1, -1), case_insensitive = iCI), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = c(1, 
 call| -->    -1)), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = stringi::stri_c("[", 
 call| -->    pattern[[iP]], "]"), i = c(1, -1), merge = FALSE), expected) 
iX =  1 ; iP =  3 ; iCI =  FALSE 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = c(1, -1), case_insensitive = iCI), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = c(1, -1), case_insensitive = iCI), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = c(1, 
 call| -->    -1)), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = stringi::stri_c("[", 
 call| -->    pattern[[iP]], "]"), i = c(1, -1), merge = FALSE), expected) 
iX =  2 ; iP =  1 ; iCI =  TRUE 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = c(1, -1), case_insensitive = iCI), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = c(1, -1), case_insensitive = iCI), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = c(1, 
 call| -->    -1)), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = stringi::stri_c("[", 
 call| -->    pattern[[iP]], "]"), i = c(1, -1), merge = FALSE), expected) 
iX =  2 ; iP =  1 ; iCI =  FALSE 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = c(1, -1), case_insensitive = iCI), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = c(1, -1), case_insensitive = iCI), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = c(1, 
 call| -->    -1)), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = stringi::stri_c("[", 
 call| -->    pattern[[iP]], "]"), i = c(1, -1), merge = FALSE), expected) 
iX =  2 ; iP =  2 ; iCI =  TRUE 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = c(1, -1), case_insensitive = iCI), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = c(1, -1), case_insensitive = iCI), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = c(1, 
 call| -->    -1)), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = stringi::stri_c("[", 
 call| -->    pattern[[iP]], "]"), i = c(1, -1), merge = FALSE), expected) 
iX =  2 ; iP =  2 ; iCI =  FALSE 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = c(1, -1), case_insensitive = iCI), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = c(1, -1), case_insensitive = iCI), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = c(1, 
 call| -->    -1)), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = stringi::stri_c("[", 
 call| -->    pattern[[iP]], "]"), i = c(1, -1), merge = FALSE), expected) 
iX =  2 ; iP =  3 ; iCI =  TRUE 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = c(1, -1), case_insensitive = iCI), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = c(1, -1), case_insensitive = iCI), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = c(1, 
 call| -->    -1)), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = stringi::stri_c("[", 
 call| -->    pattern[[iP]], "]"), i = c(1, -1), merge = FALSE), expected) 
iX =  2 ; iP =  3 ; iCI =  FALSE 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = c(1, -1), case_insensitive = iCI), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = c(1, -1), case_insensitive = iCI), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = c(1, 
 call| -->    -1)), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = stringi::stri_c("[", 
 call| -->    pattern[[iP]], "]"), i = c(1, -1), merge = FALSE), expected) 
iX =  3 ; iP =  1 ; iCI =  TRUE 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = c(1, -1), case_insensitive = iCI), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = c(1, -1), case_insensitive = iCI), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = c(1, 
 call| -->    -1)), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = stringi::stri_c("[", 
 call| -->    pattern[[iP]], "]"), i = c(1, -1), merge = FALSE), expected) 
iX =  3 ; iP =  1 ; iCI =  FALSE 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = c(1, -1), case_insensitive = iCI), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = c(1, -1), case_insensitive = iCI), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = c(1, 
 call| -->    -1)), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = stringi::stri_c("[", 
 call| -->    pattern[[iP]], "]"), i = c(1, -1), merge = FALSE), expected) 
iX =  3 ; iP =  2 ; iCI =  TRUE 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = c(1, -1), case_insensitive = iCI), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = c(1, -1), case_insensitive = iCI), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = c(1, 
 call| -->    -1)), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = stringi::stri_c("[", 
 call| -->    pattern[[iP]], "]"), i = c(1, -1), merge = FALSE), expected) 
iX =  3 ; iP =  2 ; iCI =  FALSE 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = c(1, -1), case_insensitive = iCI), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = c(1, -1), case_insensitive = iCI), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = c(1, 
 call| -->    -1)), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = stringi::stri_c("[", 
 call| -->    pattern[[iP]], "]"), i = c(1, -1), merge = FALSE), expected) 
iX =  3 ; iP =  3 ; iCI =  TRUE 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = c(1, -1), case_insensitive = iCI), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = c(1, -1), case_insensitive = iCI), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = c(1, 
 call| -->    -1)), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = stringi::stri_c("[", 
 call| -->    pattern[[iP]], "]"), i = c(1, -1), merge = FALSE), expected) 
iX =  3 ; iP =  3 ; iCI =  FALSE 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], fixed = pattern[[iP]], 
 call| -->    i = c(1, -1), case_insensitive = iCI), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], regex = pattern[[iP]], 
 call| -->    i = c(1, -1), case_insensitive = iCI), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], coll = pattern[[iP]], i = c(1, 
 call| -->    -1)), expected) 
----- PASSED      : test-stri_locate_ith_general.R<359--408>
 call| expect_equal(stri_locate_ith(x[[iX]], charclass = stringi::stri_c("[", 
 call| -->    pattern[[iP]], "]"), i = c(1, -1), merge = FALSE), expected) 

test-stri_locate_ith_general.R  503 tests OK 
test-stri_locate_ith_general.R  503 tests OK 
test-stri_locate_ith_general.R  503 tests OK 
test-stri_locate_ith_general.R  504 tests OK 
test-stri_locate_ith_general.R  504 tests OK 
test-stri_locate_ith_general.R  505 tests OK 
test-stri_locate_ith_general.R  506 tests OK 
test-stri_locate_ith_general.R  507 tests OK 
test-stri_locate_ith_general.R  508 tests OK 
test-stri_locate_ith_general.R  509 tests OK 
test-stri_locate_ith_general.R  509 tests OK 
test-stri_locate_ith_general.R  510 tests OK 
test-stri_locate_ith_general.R  510 tests OK 
test-stri_locate_ith_general.R  510 tests OK 
test-stri_locate_ith_general.R  511 tests OK 
test-stri_locate_ith_general.R  512 tests OK 
test-stri_locate_ith_general.R  513 tests OK 
test-stri_locate_ith_general.R  513 tests OK 
test-stri_locate_ith_general.R  513 tests OK 
test-stri_locate_ith_general.R  514 tests OK 
test-stri_locate_ith_general.R  514 tests OK 
test-stri_locate_ith_general.R  514 tests OK 
test-stri_locate_ith_general.R  515 tests OK 
test-stri_locate_ith_general.R  516 tests OK 
test-stri_locate_ith_general.R  517 tests OK 
test-stri_locate_ith_general.R  518 tests OK 
test-stri_locate_ith_general.R  519 tests OK 
test-stri_locate_ith_general.R  519 tests OK 
test-stri_locate_ith_general.R  519 tests OK 
test-stri_locate_ith_general.R  520 tests OK 
test-stri_locate_ith_general.R  521 tests OK 
test-stri_locate_ith_general.R  522 tests OK 
test-stri_locate_ith_general.R  522 tests OK 
test-stri_locate_ith_general.R  522 tests OK 
test-stri_locate_ith_general.R  522 tests OK 
test-stri_locate_ith_general.R  522 tests OK 
test-stri_locate_ith_general.R  523 tests OK 7.3s

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

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.....    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.....    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.....    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.....    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.....   10 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.....   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.....   11 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.....   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.....   12 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.....   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.....   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.....   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.....   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.....   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.....   18 tests OK 
test-atomic_conversions.R.....   18 tests OK 
test-atomic_conversions.R.....   18 tests OK 
test-atomic_conversions.R.....   18 tests OK 
test-atomic_conversions.R.....   18 tests OK 
test-atomic_conversions.R.....   18 tests OK 
test-atomic_conversions.R.....   18 tests OK 
test-atomic_conversions.R.....   18 tests OK 
test-atomic_conversions.R.....   18 tests OK 
test-atomic_conversions.R.....   18 tests OK 
test-atomic_conversions.R.....   18 tests OK 
test-atomic_conversions.R.....   19 tests OK 
test-atomic_conversions.R.....   19 tests OK 
test-atomic_conversions.R.....   19 tests OK 
test-atomic_conversions.R.....   19 tests OK 
test-atomic_conversions.R.....   20 tests OK 
test-atomic_conversions.R.....   20 tests OK 
test-atomic_conversions.R.....   20 tests OK 
test-atomic_conversions.R.....   20 tests OK 
test-atomic_conversions.R.....   21 tests OK 
test-atomic_conversions.R.....   21 tests OK 
test-atomic_conversions.R.....   21 tests OK 
test-atomic_conversions.R.....   21 tests OK 
test-atomic_conversions.R.....   22 tests OK 
test-atomic_conversions.R.....   22 tests OK 
test-atomic_conversions.R.....   22 tests OK 
test-atomic_conversions.R.....   22 tests OK 
test-atomic_conversions.R.....   22 tests OK 
test-atomic_conversions.R.....   22 tests OK 
test-atomic_conversions.R.....   22 tests OK 
test-atomic_conversions.R.....   22 tests OK 
test-atomic_conversions.R.....   22 tests OK 
test-atomic_conversions.R.....   22 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.....   23 tests OK 
test-atomic_conversions.R.....   23 tests OK 
test-atomic_conversions.R.....   23 tests OK 
test-atomic_conversions.R.....   23 tests OK 
test-atomic_conversions.R.....   23 tests OK 
test-atomic_conversions.R.....   23 tests OK 
test-atomic_conversions.R.....   23 tests OK 
test-atomic_conversions.R.....   24 tests OK 30ms

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

test-aaa1.R...................    0 tests    
test-aaa1.R...................    1 tests OK 
test-aaa1.R...................    2 tests OK 
test-aaa1.R...................    3 tests OK 
test-aaa1.R...................    4 tests OK [1] "D:/RCompile/CRANincoming/R-devel/lib/tinycodet/tinytest/special"

test-aaa1.R...................    4 tests OK 
test-aaa1.R...................    5 tests OK 
test-aaa1.R...................    6 tests OK 55ms

test-aaa2-pversion.R..........    0 tests    
test-aaa2-pversion.R..........    0 tests    
test-aaa2-pversion.R..........    0 tests    
test-aaa2-pversion.R..........    0 tests    
test-aaa2-pversion.R..........    0 tests    
test-aaa2-pversion.R..........    0 tests    [1] "D:\\temp\\Rtmpa2sKwi/fake_lib1"

test-aaa2-pversion.R..........    0 tests    [1] "D:\\temp\\Rtmpa2sKwi/fake_lib2"

test-aaa2-pversion.R..........    0 tests    [1] "D:\\temp\\Rtmpa2sKwi/fake_lib3"

test-aaa2-pversion.R..........    0 tests    [1] "D:\\temp\\Rtmpa2sKwi/newlib"

test-aaa2-pversion.R..........    0 tests    
test-aaa2-pversion.R..........    0 tests    
test-aaa2-pversion.R..........    1 tests OK 
test-aaa2-pversion.R..........    1 tests OK 
test-aaa2-pversion.R..........    1 tests OK 
test-aaa2-pversion.R..........    1 tests OK 
test-aaa2-pversion.R..........    2 tests OK 
test-aaa2-pversion.R..........    3 tests OK 
test-aaa2-pversion.R..........    3 tests OK 
test-aaa2-pversion.R..........    3 tests OK 
test-aaa2-pversion.R..........    4 tests OK 
test-aaa2-pversion.R..........    5 tests OK 
test-aaa2-pversion.R..........    6 tests OK 
test-aaa2-pversion.R..........    7 tests OK 
test-aaa2-pversion.R..........    8 tests OK 
test-aaa2-pversion.R..........    9 tests OK 
test-aaa2-pversion.R..........   10 tests OK 
test-aaa2-pversion.R..........   11 tests OK 
test-aaa2-pversion.R..........   12 tests OK 17ms

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

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

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


test-import_as-special.R......   14 tests OK 
test-import_as-special.R......   14 tests OK 
test-import_as-special.R......   14 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 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......   17 tests OK 
test-import_as-special.R......   17 tests OK 
test-import_as-special.R......   17 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......   20 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......   24 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 0.5s

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

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

test-import_general-special.R.    0 tests    [1] "D:\\temp\\Rtmpa2sKwi/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 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.    3 tests OK 
test-import_general-special.R.    4 tests OK 
test-import_general-special.R.    4 tests OK Checking for conflicting infix operators in the current environment...
Placing infix operators in current environment...
Done

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

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

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

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

test-import_general-special.R.    9 tests OK 
test-import_general-special.R.   10 tests OK 
test-import_general-special.R.   11 tests OK Importing packages and registering methods...

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

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

test-import_general-special.R.   14 tests OK 
test-import_general-special.R.   15 tests OK 
test-import_general-special.R.   16 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.   16 tests OK 
test-import_general-special.R.   16 tests OK 
test-import_general-special.R.   16 tests OK 
test-import_general-special.R.   16 tests OK 
test-import_general-special.R.   16 tests OK 
test-import_general-special.R.   16 tests OK 
test-import_general-special.R.   16 tests OK 
test-import_general-special.R.   17 tests OK 
test-import_general-special.R.   17 tests OK 
test-import_general-special.R.   17 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.   17 tests OK 
test-import_general-special.R.   18 tests OK 
test-import_general-special.R.   18 tests OK 
test-import_general-special.R.   18 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.   18 tests OK 
test-import_general-special.R.   19 tests OK 0.5s

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

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

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

test-import_inops-expose-alias-special.R    0 tests    
test-import_inops-expose-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-expose-alias-special.R    1 tests OK 
test-import_inops-expose-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-expose-alias-special.R    2 tests OK 
test-import_inops-expose-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-expose-alias-special.R    3 tests OK 
test-import_inops-expose-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

test-import_inops-expose-alias-special.R    4 tests OK 0.1s

test-import_inops-expose-pkg-special.R    0 tests    
test-import_inops-expose-pkg-special.R    0 tests    
test-import_inops-expose-pkg-special.R    0 tests    
test-import_inops-expose-pkg-special.R    0 tests    
test-import_inops-expose-pkg-special.R    0 tests    [1] "D:\\temp\\Rtmpa2sKwi/fake_lib1"

test-import_inops-expose-pkg-special.R    0 tests    [1] "D:\\temp\\Rtmpa2sKwi/fake_lib2"

test-import_inops-expose-pkg-special.R    0 tests    [1] "D:\\temp\\Rtmpa2sKwi/fake_lib3"

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

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

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

test-import_inops-expose-pkg-special.R    3 tests OK 
test-import_inops-expose-pkg-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
Removing the following infix operators:
%op22%, %op21%
Done
Removing the following infix operators:
%op32%, %op31%, %opover%
Done

test-import_inops-expose-pkg-special.R    4 tests OK 
test-import_inops-expose-pkg-special.R    4 tests OK 
test-import_inops-expose-pkg-special.R    5 tests OK 
test-import_inops-expose-pkg-special.R    5 tests OK 
test-import_inops-expose-pkg-special.R    6 tests OK 
test-import_inops-expose-pkg-special.R    7 tests OK 
test-import_inops-expose-pkg-special.R    7 tests OK Checking for conflicting infix operators in the current environment...
Placing infix operators in current environment...
Done

test-import_inops-expose-pkg-special.R    8 tests OK 66ms

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

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

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

test-import_inops-unexpose-alias-special.R    0 tests    
test-import_inops-unexpose-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
Removing the following infix operators:
%op31%, %op32%, %op21%, %op22%, %op11%, %opover%, %op12%
Done

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

Checking for conflicting infix operators in the current environment...
Placing infix operators in current environment...
Done
Importing packages and registering methods...
Done
You can now access the functions using `to2.$`
For conflicts report, packages order, and other attributes, run `attr.import(to2.)` 

Checking for conflicting infix operators in the current environment...
Placing infix operators in current environment...
Done
Importing packages and registering methods...
Done
You can now access the functions using `to1.$`
For conflicts report, packages order, and other attributes, run `attr.import(to1.)` 

No infix operators to unexpose

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

No infix operators to unexpose

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

No infix operators to unexpose

test-import_inops-unexpose-alias-special.R    7 tests OK 98ms

test-import_inops-unexpose-pkg-special.R    0 tests    
test-import_inops-unexpose-pkg-special.R    0 tests    
test-import_inops-unexpose-pkg-special.R    0 tests    
test-import_inops-unexpose-pkg-special.R    0 tests    
test-import_inops-unexpose-pkg-special.R    0 tests    [1] "D:\\temp\\Rtmpa2sKwi/fake_lib1"

test-import_inops-unexpose-pkg-special.R    0 tests    [1] "D:\\temp\\Rtmpa2sKwi/fake_lib2"

test-import_inops-unexpose-pkg-special.R    0 tests    [1] "D:\\temp\\Rtmpa2sKwi/fake_lib3"

test-import_inops-unexpose-pkg-special.R    0 tests    
test-import_inops-unexpose-pkg-special.R    0 tests    Checking for conflicting infix operators in the current environment...
Placing infix operators in current environment...
Done
Removing the following infix operators:
%op32%, %op31%, %opover%
Done

test-import_inops-unexpose-pkg-special.R    1 tests OK 
test-import_inops-unexpose-pkg-special.R    1 tests OK 
test-import_inops-unexpose-pkg-special.R    1 tests OK 
test-import_inops-unexpose-pkg-special.R    2 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
No infix operators to unexpose

test-import_inops-unexpose-pkg-special.R    3 tests OK 
test-import_inops-unexpose-pkg-special.R    3 tests OK 
test-import_inops-unexpose-pkg-special.R    4 tests OK No infix operators to unexpose

test-import_inops-unexpose-pkg-special.R    5 tests OK 
test-import_inops-unexpose-pkg-special.R    5 tests OK 
test-import_inops-unexpose-pkg-special.R    6 tests OK No infix operators to unexpose

test-import_inops-unexpose-pkg-special.R    7 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\\Rtmpa2sKwi/fake_lib1"

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

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

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

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

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

test-zzz.R....................    0 tests    
test-zzz.R....................    0 tests    
test-zzz.R....................    0 tests    
test-zzz.R....................    1 tests OK 41ms
All ok, 122 results (1.5s)
There were 50 or more warnings (use warnings() to see the first 50)
> 
> 
> proc.time()
   user  system elapsed 
  40.45    1.68   42.14