/tests/testthat/test-locate.R

https://github.com/qinwf/re2r · R · 296 lines · 230 code · 43 blank · 23 comment · 3 complexity · 63e35acaa0b2651fa0b41b6999dd28d5 MD5 · raw file 

    

  1. context("test locate")
    2. 

  2. source('helper.R')
    3. 

  3. 

  4. test_that("re2_locate", {
    5. 

  5.     tta = function(string,
    6. 

  6.                    pattern,
    7. 

  7.                    res,
    8. 

  8.                    rep_res = rep(res, 1000),
    9. 

  9.                    parallel_rep = FALSE) {
    10. 

  10.         eq_with_class(re2_locate_all(string, pattern), res)
    11. 

  11.         eq_with_class(re2_locate_all(string, pattern, parallel = T), res)
    12. 

  12.         eq_with_class(re2_locate_all(
    13. 

  13.             string,
    14. 

  14.             pattern,
    15. 

  15.             parallel = T,
    16. 

  16.             grain_size = 1
    17. 

  17.         ),
    18. 

  18.         res)
    19. 

  19.         if (parallel_rep) {
    20. 

  20.             eq_with_class(re2_locate_all(
    21. 

  21.                 rep(string, 1000),
    22. 

  22.                 pattern,
    23. 

  23.                 parallel = T,
    24. 

  24.                 grain_size = 1
    25. 

  25.             ),
    26. 

  26.             rep_res)
    27. 

  27.         }
    28. 

  28.     }
    29. 

  29.     tt = function(string,
    30. 

  30.                   pattern,
    31. 

  31.                   res,
    32. 

  32.                   rep_res = NULL,
    33. 

  33.                   parallel_rep = FALSE) {
    34. 

  34.         eq_with_class(re2_locate(string, pattern), res)
    35. 

  35.         eq_with_class(re2_locate(string, pattern, parallel = T), res)
    36. 

  36.         eq_with_class(re2_locate(
    37. 

  37.             string,
    38. 

  38.             pattern,
    39. 

  39.             parallel = T,
    40. 

  40.             grain_size = 1
    41. 

  41.         ),
    42. 

  42.         res)
    43. 

  43.         if (parallel_rep) {
    44. 

  44.             eq_with_class(re2_locate(
    45. 

  45.                 rep(string, 1000),
    46. 

  46.                 pattern,
    47. 

  47.                 parallel = T,
    48. 

  48.                 grain_size = 1
    49. 

  49.             ),
    50. 

  50.             rep_res)
    51. 

  51.         }
    52. 

  52.     }
    53. 

  53.     res = list(
    54. 

  54.         structure(
    55. 

  55.             c(NA_integer_, NA_integer_),
    56. 

  56.             .Dim = 1:2,
    57. 

  57.             .Dimnames = list(NULL, c("start", "end"))
    58. 

  58.         ),
    59. 

  59.         structure(1:2, .Dim = 1:2, .Dimnames = list(NULL, c("start", "end")))
    60. 

  60.     )
    61. 

  61.     tta(c(NA, "sd"), "sd", res)
    62. 

  62. 

  63.     res = structure(c(NA, 1L, NA, 2L),
    64. 

  64.                     .Dim = c(2L, 2L),
    65. 

  65.                     .Dimnames = list(NULL, c("start", "end")))
    66. 

  66.     tt(c(NA, "sd"), "sd", res)
    67. 

  67. 

  68. 

  69.     res_2 = re2_locate_all(c(NA, "sds"), "sd")
    70. 

  70. 

  71.     expect_equal(sub_string("sds", res_2[[2]]), "sd")
    72. 

  72.     expect_equal(sub_string("sds", 1, 2), "sd")
    73. 

  73. 

  74.     # NULL
    75. 

  75.     res = structure(integer(0),
    76. 

  76.                     .Dim = c(0L, 2L),
    77. 

  77.                     .Dimnames = list(NULL, c("start", "end")))
    78. 

  78.     tt(NULL, pattern = "sd", res)
    79. 

  79. 

  80.     # re2_locate_all
    81. 

  81.     res = list(
    82. 

  82.         structure(
    83. 

  83.             integer(0),
    84. 

  84.             .Dim = c(0L, 2L),
    85. 

  85.             .Dimnames = list(NULL, c("start", "end"))
    86. 

  86.         ),
    87. 

  87.         structure(
    88. 

  88.             integer(0),
    89. 

  89.             .Dim = c(0L, 2L),
    90. 

  90.             .Dimnames = list(NULL, c("start", "end"))
    91. 

  91.         ),
    92. 

  92.         structure(
    93. 

  93.             c(NA_integer_, NA_integer_),
    94. 

  94.             .Dim = 1:2,
    95. 

  95.             .Dimnames = list(NULL, c("start", "end"))
    96. 

  96.         )
    97. 

  97.     )
    98. 

  98.     tta(c("as", "as", NA), pattern = "sd", res)
    99. 

  99. 

  100.     # re2_locate
    101. 

  101.     res =  structure(
    102. 

  102.         c(
    103. 

  103.             NA_integer_,
    104. 

  104.             NA_integer_,
    105. 

  105.             NA_integer_,
    106. 

  106.             NA_integer_,
    107. 

  107.             NA_integer_,
    108. 

  108.             NA_integer_
    109. 

  109.         ),
    110. 

  110.         .Dim = c(3L, 2L),
    111. 

  111.         .Dimnames = list(NULL, c("start", "end"))
    112. 

  112.     )
    113. 

  113.     tt(c("as", "as", NA), pattern = "sd", res)
    114. 

  114. 

  115.     # test locate empty string
    116. 

  116.     # NULL
    117. 

  117.     res = structure(integer(0),
    118. 

  118.                     .Dim = c(0L, 2L),
    119. 

  119.                     .Dimnames = list(NULL, c("start", "end")))
    120. 

  120.     tt(NULL, pattern = "", res)
    121. 

  121. 

  122.     # re2_locate_all
    123. 

  123.     res = list(structure(c(1L, 2L, 3L, 0L, 1L, 2L), .Dim = c(3L, 2L), .Dimnames = list(
    124. 

  124.         NULL, c("start", "end"))), structure(c(1L, 2L, 3L, 0L, 1L,
    125. 

  125.                                                2L), .Dim = c(3L, 2L), .Dimnames = list(NULL, c("start", "end"
    126. 

  126.                                                ))), structure(c(NA_integer_, NA_integer_), .Dim = 1:2, .Dimnames = list(
    127. 

  127.                                                    NULL, c("start", "end"))))
    128. 

  128. 

  129.     tta(c("as", "as", NA), pattern = "", res)
    130. 

  130. 

  131. 

  132.     # re2_locate
    133. 

  133.     res = structure(c(1L, 1L, NA, 0L, 0L, NA),
    134. 

  134.                     .Dim = c(3L, 2L),
    135. 

  135.                     .Dimnames = list(NULL, c("start", "end")))
    136. 

  136.     tt(c("as", "as", NA), pattern = "", res)
    137. 

  137. 

  138.     # "\\P{M}" word bound
    139. 

  139.     res = structure(c(1L, 1L, NA, 0L, 0L, NA),
    140. 

  140.                     .Dim = c(3L, 2L),
    141. 

  141.                     .Dimnames = list(NULL, c("start", "end")))
    142. 

  142.     res = list(
    143. 

  143.         structure(
    144. 

  144.             c(1L, 2L, 3L, 4L, 5L, 6L, 1L, 2L, 3L, 4L, 5L,
    145. 

  145.               6L),
    146. 

  146.             .Dim = c(6L, 2L),
    147. 

  147.             .Dimnames = list(NULL, c("start", "end"))
    148. 

  148.         ),
    149. 

  149.         structure(
    150. 

  150.             c(1L, 2L, 3L, 4L, 5L, 1L, 2L, 3L, 4L, 5L),
    151. 

  151.             .Dim = c(5L, 2L),
    152. 

  152.             .Dimnames = list(NULL, c("start", "end"))
    153. 

  153.         ),
    154. 

  154.         structure(
    155. 

  155.             c(NA_integer_, NA_integer_),
    156. 

  156.             .Dim = 1:2,
    157. 

  157.             .Dimnames = list(NULL, c("start", "end"))
    158. 

  158.         )
    159. 

  159.     )
    160. 

  160.     tta(c("asasd%", "\\P{M}", NA), pattern = "\\P{M}", res)
    161. 

  161. 

  162.     # test locate $
    163. 

  163.     # NULL
    164. 

  164.     res = structure(integer(0),
    165. 

  165.                     .Dim = c(0L, 2L),
    166. 

  166.                     .Dimnames = list(NULL, c("start", "end")))
    167. 

  167.     tt(NULL, pattern = "$", res)
    168. 

  168. 

  169.     # re2_locate_all
    170. 

  170.     res = list(
    171. 

  171.         structure(
    172. 

  172.             c(3L, 2L),
    173. 

  173.             .Dim = 1:2,
    174. 

  174.             .Dimnames = list(NULL, c("start", "end"))
    175. 

  175.         ),
    176. 

  176.         structure(
    177. 

  177.             c(3L, 2L),
    178. 

  178.             .Dim = 1:2,
    179. 

  179.             .Dimnames = list(NULL, c("start", "end"))
    180. 

  180.         ),
    181. 

  181.         structure(
    182. 

  182.             c(NA_integer_, NA_integer_),
    183. 

  183.             .Dim = 1:2,
    184. 

  184.             .Dimnames = list(NULL, c("start", "end"))
    185. 

  185.         )
    186. 

  186.     )
    187. 

  187.     tta(c("as", "as", NA), pattern = "$", res)
    188. 

  188. 

  189.     # re2_locate
    190. 

  190.     res = structure(c(3L, 3L, NA, 2L, 2L, NA),
    191. 

  191.                     .Dim = c(3L, 2L),
    192. 

  192.                     .Dimnames = list(NULL, c("start", "end")))
    193. 

  193.     tt(c("as", "as", NA), pattern = "$", res)
    194. 

  194. 

  195.     res = structure(c(1L, 1L, NA, 0L, 0L, NA),
    196. 

  196.                     .Dim = c(3L, 2L),
    197. 

  197.                     .Dimnames = list(NULL, c("start", "end")))
    198. 

  198.     tt(c("as", "as", NA), pattern = "^", res)
    199. 

  199. 

  200. })
    201. 

  201. 

  202. 

  203. test_that("test sub_string", {
    204. 

  204.     sds = "sds"
    205. 

  205.     sub_string(sds, 1, 2) <- "ab"
    206. 

  206. 

  207.     sds = "sds"
    208. 

  208.     sub_string(sds, from = matrix(c(1, 2), ncol = 2)) <- "ab"
    209. 

  209.     expect_identical(sds, "abs")
    210. 

  210. })
    211. 

  211. 

  212. test_that("vectorize locate", {
    213. 

  213.     locate_list = list(list("bar", c("b", "a"), structure(
    214. 

  214.         c(1L, 2L, 1L, 2L),
    215. 

  215.         .Dim = c(2L, 2L),
    216. 

  216.         .Dimnames = list(NULL, c("start", "end"))
    217. 

  217.     )))
    218. 

  218.     for (ind in locate_list) {
    219. 

  219.         eq_with_class(re2_locate(ind[[1]], ind[[2]]), ind[[3]])
    220. 

  220.     }
    221. 

  221. })
    222. 

  222. 

  223. test_that("stringi tests",{
    224. 

  224.     expect_is(re2_locate_all(character(0), "a"), "list")
    225. 

  225. 

  226.     # differences for empty string
    227. 

  227.     # expect_equivalent(re2_locate_all(NA, character(0)), list())
    228. 

  228.     # expect_equivalent(re2_locate_all(LETTERS, character(0)), list())
    229. 

  229.     # suppressWarnings(expect_equivalent(re2_locate_all("abc", ""), list(matrix(c(NA_integer_,NA_integer_)))))
    230. 

  230.     # suppressWarnings(expect_equivalent(re2_locate_all("", ""), list(matrix(c(NA_integer_,NA_integer_)))))
    231. 

  231.     # suppressWarnings(expect_equivalent(re2_locate_all("", "abc"), list(matrix(c(NA_integer_,NA_integer_)))))
    232. 

  232. 

  233.     eq_with_class(re2_locate_all(character(0), NA), list())
    234. 

  234. 

  235.     expect_equal(as.integer(re2_locate_all(NA, "[a-z]")[[1]]),
    236. 

  236.                       c(NA_integer_, NA_integer_))
    237. 

  237.     expect_equal(as.integer(re2_locate_all("?", "[a-z]")[[1]]),
    238. 

  238.                       integer(0))
    239. 

  239. 

  240.     eq_with_class(re2_locate_all("1a\u0105a", "\u0105"), list(matrix(c(3,3))))
    241. 

  241.     eq_with_class(re2_locate_all("X\U00024B62\U00024B63\U00024B64X",
    242. 

  242.                                             c("\U00024B62", "\U00024B63", "\U00024B64")),
    243. 

  243.                       list(matrix(c(2L,2L)), matrix(c(3L,3L)), matrix(c(4L,4L))))
    244. 

  244.     eq_with_class(re2_locate_all("aaa", "aa"), list(matrix(c(1,2))))
    245. 

  245.     eq_with_class(re2_locate_all(c("", " "), "^.*$"), list(matrix(c(1,0)), matrix(c(1,1))))
    246. 

  246. 

  247.     eq_with_class(re2_locate_all("1a\u0105a", "a.a"), list(matrix(c(2,4))))
    248. 

  248.     eq_with_class(re2_locate_all("ala ola ela ula", ".la"), list(matrix(c(1,5,9,13,3,7,11,15),ncol=2)))
    249. 

  249.     eq_with_class(re2_locate_all("ala ola ela ula", "(a|u|z)la"), list(matrix(c(1,13,3,15),ncol=2)))
    250. 

  250. 

  251.     eq_with_class(re2_locate_all("aabaaaba", "(a+b)+"), list(matrix(c(1,7))))
    252. 

  252.     eq_with_class(re2_locate_all("aabaacba", "(a+b)+"), list(matrix(c(1,3))))
    253. 

  253.     eq_with_class(re2_locate_all("ababacba", "(a+b)+"), list(matrix(c(1,4))))
    254. 

  254. 

  255.     eq_with_class(re2_locate_all("aabdaaaba", "(a+b)+"), list(matrix(c(1,5,3,8),ncol=2)))
    256. 

  256.     eq_with_class(re2_locate_all("aabdaacba", "(a+b)+"), list(matrix(c(1,3))))
    257. 

  257.     eq_with_class(re2_locate_all("ababdacba", "(a+b)+"), list(matrix(c(1,4))))
    258. 

  258. 

  259. 

  260.     eq_with_class(re2_locate_all(c("\u0105\u0106\u0107", "\u0105\u0107"), "\u0106*"),
    261. 

  261.                       list(matrix(ncol=2, c(1,2,3,4,0,2,2,3)), matrix(ncol=2, c(1,2,3,0,1,2)))) # match of zero length
    262. 

  262. 

  263. 

  264.     # locate first
    265. 

  265. 

  266.     expect_is(re2_locate(character(0), "a"), "re2_matrix")
    267. 

  267. 

  268.     # expect_equivalent(nrow(re2_locate(NA, character(0))), 0)
    269. 

  269.     expect_equal(nrow(re2_locate(character(0), NA)), 0)
    270. 

  270.     # expect_equivalent(nrow(re2_locate(LETTERS, character(0))), 0)
    271. 

  271.     #suppressWarnings(expect_equivalent(re2_locate("abc", ""), matrix(c(NA_integer_,NA_integer_))))
    272. 

  272.     suppressWarnings(eq_with_class(re2_locate("", "abc"), matrix(c(NA_integer_,NA_integer_))))
    273. 

  273.     # suppressWarnings(expect_equivalent(re2_locate("", ""), matrix(c(NA_integer_,NA_integer_))))
    274. 

  274.     eq_with_class(re2_locate(c("", " "), "^.*$"), matrix(c(1,0,1,1), byrow=TRUE, ncol=2))
    275. 

  275. 

  276.     eq_with_class(re2_locate("X\u0104\u0105\u106X", "\u0105"), matrix(c(3L,3L)))
    277. 

  277.     eq_with_class(re2_locate("X\u9999\u9998\u9997X", "\u9998"), matrix(c(3L,3L)))
    278. 

  278.     eq_with_class(re2_locate("X\U00024B62\U00024B63\U00024B64X", "\U00024B63"), matrix(c(3L,3L)))
    279. 

  279.     eq_with_class(re2_locate("aaa", "aa"), matrix(c(1L,2L)))
    280. 

  280. 

  281.     eq_with_class(re2_locate("1a\u0105a", "a.a"), matrix(c(2,4)))
    282. 

  282.     eq_with_class(re2_locate("ala ola ela ula", ".la"), matrix(c(1,3)))
    283. 

  283.     eq_with_class(re2_locate("ala ola ela ula", "(e|u|z)la"), matrix(c(9,11)))
    284. 

  284. 

  285.     eq_with_class(re2_locate("aabaaaba", "(a+b)+"), matrix(c(1,7)))
    286. 

  286.     eq_with_class(re2_locate("aabaacba", "(a+b)+"), matrix(c(1,3)))
    287. 

  287.     eq_with_class(re2_locate("ababacba", "(a+b)+"), matrix(c(1,4)))
    288. 

  288. 

  289.     eq_with_class(re2_locate("aabdaaaba", "(a+b)+"), matrix(c(1,3)))
    290. 

  290.     eq_with_class(re2_locate("aabdaacba", "(a+b)+"), matrix(c(1,3)))
    291. 

  291.     eq_with_class(re2_locate("ababdacba", "(a+b)+"), matrix(c(1,4)))
    292. 

  292. 

  293. 

  294.     eq_with_class(re2_locate(c("\u0105\u0106\u0107", "\u0105\u0107"), "\u0106*"),
    295. 

  295.                       matrix(ncol=2, c(1,1,0,0))) # match of zero length
    296. 

  296. })
    297.