• using R version 4.4.3 RC (2025-02-20 r87772)
• using platform: x86_64-pc-linux-gnu
• R was compiled by     gcc-14 (Debian 14.2.0-16) 14.2.0     GNU Fortran (Debian 14.2.0-16) 14.2.0
• running under: Debian GNU/Linux trixie/sid
• using session charset: UTF-8
• checking for file ‘Rdpack/DESCRIPTION’ ... OK
• checking extension type ... Package
• this is package ‘Rdpack’ version ‘2.6.2’
• checking package namespace information ... OK
• checking package dependencies ... OK
• checking if this is a source package ... OK
• checking if there is a namespace ... OK
• checking for executable files ... OK
• checking for hidden files and directories ... OK
• checking for portable file names ... OK
• checking for sufficient/correct file permissions ... OK
• checking serialization versions ... OK
• checking whether package ‘Rdpack’ can be installed ... OK See the install log for details.
• checking package directory ... OK
• checking for future file timestamps ... OK
• checking ‘build’ directory ... OK
• checking DESCRIPTION meta-information ... OK
• checking top-level files ... OK
• checking for left-over files ... OK
• checking index information ... OK
• checking package subdirectories ... OK
• checking code files for non-ASCII characters ... OK
• checking R files for syntax errors ... OK
• checking whether the package can be loaded ... [0s/0s] OK
• checking whether the package can be loaded with stated dependencies ... [0s/0s] OK
• checking whether the package can be unloaded cleanly ... [0s/0s] OK
• checking whether the namespace can be loaded with stated dependencies ... [0s/0s] OK
• checking whether the namespace can be unloaded cleanly ... [0s/0s] OK
• checking loading without being on the library search path ... [0s/0s] OK
• checking whether startup messages can be suppressed ... [0s/1s] OK
• checking use of S3 registration ... OK
• checking dependencies in R code ... OK
• checking S3 generic/method consistency ... OK
• checking replacement functions ... OK
• checking foreign function calls ... OK
• checking R code for possible problems ... [12s/14s] OK
• checking Rd files ... [1s/2s] OK
• checking Rd metadata ... OK
• checking Rd line widths ... OK
• checking Rd cross-references ... OK
• checking for missing documentation entries ... OK
• checking for code/documentation mismatches ... OK
• checking Rd \usage sections ... OK
• checking Rd contents ... OK
• checking for unstated dependencies in examples ... OK
• checking sizes of PDF files under ‘inst/doc’ ... OK
• checking installed files from ‘inst/doc’ ... OK
• checking files in ‘vignettes’ ... OK
• checking examples ... [8s/10s] OK
• checking for unstated dependencies in ‘tests’ ... OK
• checking tests ... [6s/7s] ERROR   Running ‘testthat.R’ [5s/7s] 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   Failed with error: 'there is no package called 'yyy''   Rd source not supplied, looking for installed documentation.   Installed documentation found, processing it...    The Rd content was written to file /home/hornik/tmp/scratch/RtmpqqCpqY/file1f502415a6b57a.Rd      Parsing the Rd documentation in file /home/hornik/tmp/scratch/RtmpqqCpqY/file1f502415a6b57a.Rd ...    The Rd content was written to file /home/hornik/tmp/scratch/RtmpqqCpqY/file1f50245e7a5bd6.Rd      Parsing the Rd documentation in file /home/hornik/tmp/R.check/r-patched-gcc/Work/build/Packages/Rdpack/examples/reprompt.Rd ...    The Rd content was written to file /home/hornik/tmp/scratch/RtmpqqCpqY/file1f50245e7a5bd6.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/RtmpqqCpqY/file1f50245e7a5bd6.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 2 | SKIP 1 | PASS 40 ]      ══ Skipped tests (1) ═══════════════════════════════════════════════════════════   • empty test (1): 'test-char2Rdpiece.R:32:1'      ══ Failed tests ════════════════════════════════════════════════════════════════   ── Failure ('test-bib.R:90:5'): bib works fine ─────────────────────────────────   `insert_ref("xxx", package = "rbibutils")` did not throw an error.      [ FAIL 1 | WARN 2 | SKIP 1 | PASS 40 ]   Error: Test failures   Execution halted
• checking for unstated dependencies in vignettes ... OK
• checking package vignettes ... OK
• checking re-building of vignette outputs ... [6s/8s] OK
• checking PDF version of manual ... [8s/11s] OK
• checking HTML version of manual ... [4s/7s] OK
• checking for non-standard things in the check directory ... OK
• DONE

Status: 1 ERROR