Running ‘testthat.R’ [6s/10s]
Running the tests in ‘tests/testthat.R’ failed.
Complete output:
  > if(require("testthat")) {
  +     library(testthat)
  +     library(Rdpack)
  +     test_check("Rdpack")
  + } else
  +     warning("package 'testthat' required for 'Rdpack\'s' tests")
  Loading required package: testthat
  Rd source not supplied, looking for installed documentation.
  Installed documentation found, processing it...
  	The Rd content was written to file  /home/hornik/tmp/scratch/RtmpHPp9bk/file3eb94c13ac4999.Rd 
  
  Parsing the Rd documentation in file /home/hornik/tmp/scratch/RtmpHPp9bk/file3eb94c13ac4999.Rd ...
  	The Rd content was written to file  /home/hornik/tmp/scratch/RtmpHPp9bk/file3eb94c6f242798.Rd 
  
  Parsing the Rd documentation in file /home/hornik/tmp/R.check/r-devel-gcc/Work/build/Packages/Rdpack/examples/reprompt.Rd ...
  	The Rd content was written to file  /home/hornik/tmp/scratch/RtmpHPp9bk/file3eb94c6f242798.Rd 
  Rd source not supplied, looking for installed documentation.
  Installed documentation found, processing it...
  	The Rd content was written to file  deparse_usage.Rd 
  Rd source not supplied, looking for installed documentation.
  Installed documentation found, processing it...
  
  newargs is: data nrow ncol byrow dimnames dim start end frequency deltat ts.eps class names .Data ... 
  	The Rd content was written to file  StructureClasses.Rd 
  Rd source not supplied, looking for installed documentation.
  Installed documentation found, processing it...
  	The Rd content was written to file  show.Rd 
  Rd source not supplied, looking for installed documentation.
  Installed documentation found, processing it...
  	The Rd content was written to file  initialize-methods.Rd 
  Rd source not supplied, looking for installed documentation.
  Installed documentation found, processing it...
  	The Rd content was written to file  classRepresentation-class.Rd 
  Rd source not supplied, looking for installed documentation.
  Installed documentation found, processing it...
  	The Rd content was written to file  /home/hornik/tmp/scratch/RtmpHPp9bk/file3eb94c6f242798.Rd 
  Rd source not supplied, looking for installed documentation.
  Rd source not supplied and installed documentation not found.
  Trying a 'prompt' function to generate documentation for the object.
  	success: documentation generated using a 'prompt' function.
  	The Rd content was written to file  myshow-methods.Rd 
  Rd source not supplied, looking for installed documentation.
  Installed documentation found, processing it...
  	The Rd content was written to file  seq.Rd 
  _S_e_q_u_e_n_c_e _G_e_n_e_r_a_t_i_o_n
  
  _D_e_s_c_r_i_p_t_i_o_n:
  
       Generate regular sequences.  'seq' is a standard generic with a
       default method.  'seq.int' is a primitive which can be much faster
       but has a few restrictions.  'seq_along' and 'seq_len' are very
       fast primitives for two common cases.
  
  _U_s_a_g_e:
  
       seq(...)
       
       ## Default S3 method:
       seq(from = 1, to = 1, by = ((to - from)/(length.out - 1)),
           length.out = NULL, along.with = NULL, ...)
       
       seq.int(from, to, by, length.out, along.with, ...)
       
       seq_along(along.with)
       seq_len(length.out)
       
  _A_r_g_u_m_e_n_t_s:
  
       ...: arguments passed to or from methods.
  
  from, to: the starting and (maximal) end values of the sequence.  Of
            length '1' unless just 'from' is supplied as an unnamed
            argument.
  
        by: number: increment of the sequence.
  
  length.out: desired length of the sequence.  A non-negative number,
            which for 'seq' and 'seq.int' will be rounded up if
            fractional.
  
  along.with: take the length from the length of this argument.
  
  _D_e_t_a_i_l_s:
  
       Numerical inputs should all be finite (that is, not infinite,
       'NaN' or 'NA').
  
       The interpretation of the unnamed arguments of 'seq' and 'seq.int'
       is _not_ standard, and it is recommended always to name the
       arguments when programming.
  
       'seq' is generic, and only the default method is described here.
       Note that it dispatches on the class of the *first* argument
       irrespective of argument names.  This can have unintended
       consequences if it is called with just one argument intending this
       to be taken as 'along.with': it is much better to use 'seq_along'
       in that case.
  
       'seq.int' is an internal generic which dispatches on methods for
       '"seq"' based on the class of the first supplied argument (before
       argument matching).
  
       Typical usages are
  
       seq(from, to)
       seq(from, to, by= )
       seq(from, to, length.out= )
       seq(along.with= )
       seq(from)
       seq(length.out= )
       
       The first form generates the sequence 'from, from+/-1, ..., to'
       (identical to 'from:to').
  
       The second form generates 'from, from+by', ..., up to the sequence
       value less than or equal to 'to'.  Specifying 'to - from' and 'by'
       of opposite signs is an error.  Note that the computed final value
       can go just beyond 'to' to allow for rounding error, but is
       truncated to 'to'.  ('Just beyond' is by up to 1e-10 times
       'abs(from - to)'.)
  
       The third generates a sequence of 'length.out' equally spaced
       values from 'from' to 'to'.  ('length.out' is usually abbreviated
       to 'length' or 'len', and 'seq_len' is much faster.)
  
       The fourth form generates the integer sequence '1, 2, ...,
       length(along.with)'.  ('along.with' is usually abbreviated to
       'along', and 'seq_along' is much faster.)
  
       The fifth form generates the sequence '1, 2, ..., length(from)'
       (as if argument 'along.with' had been specified), _unless_ the
       argument is numeric of length 1 when it is interpreted as '1:from'
       (even for 'seq(0)' for compatibility with S).  Using either
       'seq_along' or 'seq_len' is much preferred (unless strict S
       compatibility is essential).
  
       The final form generates the integer sequence '1, 2, ...,
       length.out' unless 'length.out = 0', when it generates
       'integer(0)'.
  
       Very small sequences (with 'from - to' of the order of 10^{-14}
       times the larger of the ends) will return 'from'.
  
       For 'seq' (only), up to two of 'from', 'to' and 'by' can be
       supplied as complex values provided 'length.out' or 'along.with'
       is specified.  More generally, the default method of 'seq' will
       handle classed objects with methods for the 'Math', 'Ops' and
       'Summary' group generics.
  
       'seq.int', 'seq_along' and 'seq_len' are primitive.
  
  _V_a_l_u_e:
  
       'seq.int' and the default method of 'seq' for numeric arguments
       return a vector of type '"integer"' or '"double"': programmers
       should not rely on which.
  
       'seq_along' and 'seq_len' return an integer vector, unless it is a
       _long vector_ when it will be double.
  
  _R_e_f_e_r_e_n_c_e_s:
  
       Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) _The New S
       Language_.  Wadsworth & Brooks/Cole.
  
  _S_e_e _A_l_s_o:
  
       The methods 'seq.Date' and 'seq.POSIXt'.
  
       ':', 'rep', 'sequence', 'row', 'col'.
  
  _E_x_a_m_p_l_e_s:
  
       seq(0, 1, length.out = 11)
       seq(stats::rnorm(20)) # effectively 'along'
       seq(1, 9, by = 2)     # matches 'end'
       seq(1, 9, by = pi)    # stays below 'end'
       seq(1, 6, by = 3)
       seq(1.575, 5.125, by = 0.05)
       seq(17) # same as 1:17, or even better seq_len(17)
       
  
  _S_e_q_u_e_n_c_e _G_e_n_e_r_a_t_i_o_n
  
  _D_e_s_c_r_i_p_t_i_o_n:
  
       Generate regular sequences.  'seq' is a standard generic with a
       default method.  'seq.int' is a primitive which can be much faster
       but has a few restrictions.  'seq_along' and 'seq_len' are very
       fast primitives for two common cases.
  
  _U_s_a_g_e:
  
       seq()
       \\method{seq}{default}()
       seq.int()
       seq_along()
       seq_len()
       
  _A_r_g_u_m_e_n_t_s:
  
       ...: arguments passed to or from methods.
  
  from, to: the starting and (maximal) end values of the sequence.  Of
            length '1' unless just 'from' is supplied as an unnamed
            argument.
  
        by: number: increment of the sequence.
  
  length.out: desired length of the sequence.  A non-negative number,
            which for 'seq' and 'seq.int' will be rounded up if
            fractional.
  
  along.with: take the length from the length of this argument.
  
  _D_e_t_a_i_l_s:
  
       Numerical inputs should all be finite (that is, not infinite,
       'NaN' or 'NA').
  
       The interpretation of the unnamed arguments of 'seq' and 'seq.int'
       is _not_ standard, and it is recommended always to name the
       arguments when programming.
  
       'seq' is generic, and only the default method is described here.
       Note that it dispatches on the class of the *first* argument
       irrespective of argument names.  This can have unintended
       consequences if it is called with just one argument intending this
       to be taken as 'along.with': it is much better to use 'seq_along'
       in that case.
  
       'seq.int' is an internal generic which dispatches on methods for
       '"seq"' based on the class of the first supplied argument (before
       argument matching).
  
       Typical usages are
  
       seq(from, to)
       seq(from, to, by= )
       seq(from, to, length.out= )
       seq(along.with= )
       seq(from)
       seq(length.out= )
       
       The first form generates the sequence 'from, from+/-1, ..., to'
       (identical to 'from:to').
  
       The second form generates 'from, from+by', ..., up to the sequence
       value less than or equal to 'to'.  Specifying 'to - from' and 'by'
       of opposite signs is an error.  Note that the computed final value
       can go just beyond 'to' to allow for rounding error, but is
       truncated to 'to'.  ('Just beyond' is by up to 1e-10 times
       'abs(from - to)'.)
  
       The third generates a sequence of 'length.out' equally spaced
       values from 'from' to 'to'.  ('length.out' is usually abbreviated
       to 'length' or 'len', and 'seq_len' is much faster.)
  
       The fourth form generates the integer sequence '1, 2, ...,
       length(along.with)'.  ('along.with' is usually abbreviated to
       'along', and 'seq_along' is much faster.)
  
       The fifth form generates the sequence '1, 2, ..., length(from)'
       (as if argument 'along.with' had been specified), _unless_ the
       argument is numeric of length 1 when it is interpreted as '1:from'
       (even for 'seq(0)' for compatibility with S).  Using either
       'seq_along' or 'seq_len' is much preferred (unless strict S
       compatibility is essential).
  
       The final form generates the integer sequence '1, 2, ...,
       length.out' unless 'length.out = 0', when it generates
       'integer(0)'.
  
       Very small sequences (with 'from - to' of the order of 10^{-14}
       times the larger of the ends) will return 'from'.
  
       For 'seq' (only), up to two of 'from', 'to' and 'by' can be
       supplied as complex values provided 'length.out' or 'along.with'
       is specified.  More generally, the default method of 'seq' will
       handle classed objects with methods for the 'Math', 'Ops' and
       'Summary' group generics.
  
       'seq.int', 'seq_along' and 'seq_len' are primitive.
  
  _V_a_l_u_e:
  
       'seq.int' and the default method of 'seq' for numeric arguments
       return a vector of type '"integer"' or '"double"': programmers
       should not rely on which.
  
       'seq_along' and 'seq_len' return an integer vector, unless it is a
       _long vector_ when it will be double.
  
  _R_e_f_e_r_e_n_c_e_s:
  
       Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) _The New S
       Language_.  Wadsworth & Brooks/Cole.
  
  _S_e_e _A_l_s_o:
  
       The methods 'seq.Date' and 'seq.POSIXt'.
  
       ':', 'rep', 'sequence', 'row', 'col'.
  
  _E_x_a_m_p_l_e_s:
  
       seq(0, 1, length.out = 11)
       seq(stats::rnorm(20)) # effectively 'along'
       seq(1, 9, by = 2)     # matches 'end'
       seq(1, 9, by = pi)    # stays below 'end'
       seq(1, 6, by = 3)
       seq(1.575, 5.125, by = 0.05)
       seq(17) # same as 1:17, or even better seq_len(17)
       
  
  Rd source not supplied, looking for installed documentation.
  Rd source not supplied and installed documentation not found.
  Trying a 'prompt' function to generate documentation for the object.
  	success: documentation generated using a 'prompt' function.
  	The Rd content was written to file  tmp.Rd 
  Processing the Rd object...
  	The Rd content was written to file  seqB.Rd 
  _S_e_q_u_e_n_c_e _G_e_n_e_r_a_t_i_o_n
  
  _D_e_s_c_r_i_p_t_i_o_n:
  
       Generate regular sequences.  'seq' is a standard generic with a
       default method.  'seq.int' is a primitive which can be much faster
       but has a few restrictions.  'seq_along' and 'seq_len' are very
       fast primitives for two common cases.
  
  _U_s_a_g_e:
  
       seq(...)
       
       ## Default S3 method:
       seq(from = 1, to = 1, by = ((to - from)/(length.out - 1)), 
           length.out = NULL, along.with = NULL, ...)
       
       seq.int(from, to, by, length.out, along.with, ...)
       
       seq_along(along.with)
       
       seq_len(length.out)
       
       myseq(from, to, by = 1)
       
  _A_r_g_u_m_e_n_t_s:
  
       ...: arguments passed to or from methods.
  
  from, to: the starting and (maximal) end values of the sequence.  Of
            length '1' unless just 'from' is supplied as an unnamed
            argument.
  
        by: number: increment of the sequence.
  
  length.out: desired length of the sequence.  A non-negative number,
            which for 'seq' and 'seq.int' will be rounded up if
            fractional.
  
  along.with: take the length from the length of this argument.
  
  _D_e_t_a_i_l_s:
  
       Numerical inputs should all be finite (that is, not infinite,
       'NaN' or 'NA').
  
       The interpretation of the unnamed arguments of 'seq' and 'seq.int'
       is _not_ standard, and it is recommended always to name the
       arguments when programming.
  
       'seq' is generic, and only the default method is described here.
       Note that it dispatches on the class of the *first* argument
       irrespective of argument names.  This can have unintended
       consequences if it is called with just one argument intending this
       to be taken as 'along.with': it is much better to use 'seq_along'
       in that case.
  
       'seq.int' is an internal generic which dispatches on methods for
       '"seq"' based on the class of the first supplied argument (before
       argument matching).
  
       Typical usages are
  
       seq(from, to)
       seq(from, to, by= )
       seq(from, to, length.out= )
       seq(along.with= )
       seq(from)
       seq(length.out= )
       
       The first form generates the sequence 'from, from+/-1, ..., to'
       (identical to 'from:to').
  
       The second form generates 'from, from+by', ..., up to the sequence
       value less than or equal to 'to'.  Specifying 'to - from' and 'by'
       of opposite signs is an error.  Note that the computed final value
       can go just beyond 'to' to allow for rounding error, but is
       truncated to 'to'.  ('Just beyond' is by up to 1e-10 times
       'abs(from - to)'.)
  
       The third generates a sequence of 'length.out' equally spaced
       values from 'from' to 'to'.  ('length.out' is usually abbreviated
       to 'length' or 'len', and 'seq_len' is much faster.)
  
       The fourth form generates the integer sequence '1, 2, ...,
       length(along.with)'.  ('along.with' is usually abbreviated to
       'along', and 'seq_along' is much faster.)
  
       The fifth form generates the sequence '1, 2, ..., length(from)'
       (as if argument 'along.with' had been specified), _unless_ the
       argument is numeric of length 1 when it is interpreted as '1:from'
       (even for 'seq(0)' for compatibility with S).  Using either
       'seq_along' or 'seq_len' is much preferred (unless strict S
       compatibility is essential).
  
       The final form generates the integer sequence '1, 2, ...,
       length.out' unless 'length.out = 0', when it generates
       'integer(0)'.
  
       Very small sequences (with 'from - to' of the order of 10^{-14}
       times the larger of the ends) will return 'from'.
  
       For 'seq' (only), up to two of 'from', 'to' and 'by' can be
       supplied as complex values provided 'length.out' or 'along.with'
       is specified.  More generally, the default method of 'seq' will
       handle classed objects with methods for the 'Math', 'Ops' and
       'Summary' group generics.
  
       'seq.int', 'seq_along' and 'seq_len' are primitive.
  
  _V_a_l_u_e:
  
       'seq.int' and the default method of 'seq' for numeric arguments
       return a vector of type '"integer"' or '"double"': programmers
       should not rely on which.
  
       'seq_along' and 'seq_len' return an integer vector, unless it is a
       _long vector_ when it will be double.
  
  _R_e_f_e_r_e_n_c_e_s:
  
       Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) _The New S
       Language_.  Wadsworth & Brooks/Cole.
  
  _S_e_e _A_l_s_o:
  
       The methods 'seq.Date' and 'seq.POSIXt'.
  
       ':', 'rep', 'sequence', 'row', 'col'.
  
  _E_x_a_m_p_l_e_s:
  
       seq(0, 1, length.out = 11)
       seq(stats::rnorm(20)) # effectively 'along'
       seq(1, 9, by = 2)     # matches 'end'
       seq(1, 9, by = pi)    # stays below 'end'
       seq(1, 6, by = 3)
       seq(1.575, 5.125, by = 0.05)
       seq(17) # same as 1:17, or even better seq_len(17)
       
  
  
  Parsing the Rd documentation in file seq.Rd ...
  	The Rd content was written to file  seq2.Rd 
  
  Parsing the Rd documentation in file seq2.Rd ...
  	The Rd content was written to file  seq3.Rd 
  Processing the Rd object...
  	The Rd content was written to file  seq.Rd 
  Processing the Rd object...
  	The Rd content was written to file  seq.Rd 
  Processing the Rd object...
  	The Rd content was written to file  seq.Rd 
  [ FAIL 1 | WARN 0 | SKIP 1 | PASS 35 ]
  
  ══ Skipped tests (1) ═══════════════════════════════════════════════════════════
  • empty test (1): 'test-char2Rdpiece.R:32:1'
  
  ══ Failed tests ════════════════════════════════════════════════════════════════
  ── Error ('test-bib.R:90:5'): bib works fine ───────────────────────────────────
  <subscriptOutOfBoundsError/error/condition>
  Error in `s[[i]]`: subscript out of bounds
  Backtrace:
       ▆
    1. ├─testthat::expect_warning(insert_ref("xxx", package = "rbibutils")) at test-bib.R:90:5
    2. │ └─testthat:::quasi_capture(...)
    3. │   ├─testthat (local) .capture(...)
    4. │   │ └─base::withCallingHandlers(...)
    5. │   └─rlang::eval_bare(quo_get_expr(.quo), quo_get_env(.quo))
    6. └─Rdpack::insert_ref("xxx", package = "rbibutils")
    7.   ├─base::tryCatch(...)
    8.   │ └─base (local) tryCatchList(expr, classes, parentenv, handlers)
    9.   │   └─base (local) tryCatchOne(expr, names, parentenv, handlers[[1L]])
   10.   │     └─base (local) doTryCatch(return(expr), name, parentenv, handler)
   11.   ├─bibs[[key]]
   12.   └─utils:::`[[.bibentry`(bibs, key)
  
  [ FAIL 1 | WARN 0 | SKIP 1 | PASS 35 ]
  Error: Test failures
  Execution halted