.R_LIBS <- function(libp = .libPaths()) { # (>> in utils?) libp <- libp[! libp %in% .Library] if(length(libp)) paste(libp, collapse = .Platform$path.sep) else "" # character(0) is invalid for Sys.setenv() } .libPaths(tail(.libPaths(), 1), include.site=FALSE) # no extra libraries (w/ many pkgs)\n") Sys.setenv(R_LIBS = .R_LIBS() # for build.pkg() & install.packages() , R_BUILD_ENVIRON = "nothing" # avoid ~/.R/build.environ which might set R_LIBS , R_ENVIRON = "none" , R_PROFILE = "none" ) showProc.time <- local({ ## function + 'pct' variable pct <- proc.time() function(final="\n") { ## CPU elapsed __since last called__ ot <- pct ; pct <<- proc.time() cat('Time elapsed: ', format.default(round((pct - ot)[1:3], digits=3), digits=4), final) } }) ## PR 1271 detach("package:base") crashes R. tools::assertError(detach("package:base")) ## invalid 'lib.loc' stopifnot(length(installed.packages("mgcv")) == 0) ## gave a low-level error message showProc.time() ## package.skeleton() with metadata-only code ## work in current (= ./tests/ directory): tmp <- tempfile() writeLines(c('setClass("foo", contains="numeric")', 'setMethod("show", "foo",', ' function(object) cat("I am a \\"foo\\"\\n"))'), tmp) if(file.exists("myTst")) unlink("myTst", recursive=TRUE) package.skeleton("myTst", code_files = tmp)# with a file name warning file.copy(tmp, (tm2 <- paste(tmp,".R", sep=""))) unlink("myTst", recursive=TRUE) op <- options(warn=2) # *NO* "invalid file name" warning {failed in 2.7.[01]}: package.skeleton("myTst", code_files = tm2) options(op) ##_2_ only a class, no generics/methods: writeLines(c('setClass("DocLink",', 'representation(name="character",', ' desc="character"))'), tmp) if(file.exists("myTst2")) unlink("myTst2", recursive=TRUE) package.skeleton("myTst2", code_files = tmp) ##- end_2_ # failed in R 2.11.0 stopifnot(1 == grep("setClass", readLines(list.files("myTst/R", full.names=TRUE))), c("foo-class.Rd","show-methods.Rd") %in% list.files("myTst/man")) ## failed for several reasons in R < 2.7.0 ## ## Part 2: -- build, install, load and "inspect" the package: build.pkg <- function(dir, destdir = NULL, ignore.stderr = FALSE, no.latex=TRUE) { dir <- normalizePath(dir) if(length(dir) > 1) return(lapply(dir, build.pkg, destdir=destdir, ignore.stderr=ignore.stderr, no.latex=no.latex)) ## else one 'dir': stopifnot(dir.exists(dir), file.exists(DESC <- file.path(dir, "DESCRIPTION"))) pkgName <- sub("^[A-Za-z]+: ", "", grep("^Package: ", readLines(DESC), value=TRUE)) patt <- paste(pkgName, ".*tar\\.gz$", sep="_") unlink(dir('.', pattern = patt)) Rcmd <- paste(shQuote(file.path(R.home("bin"), "R")), "CMD") r <- system(paste(Rcmd, "build --keep-empty-dirs", if(no.latex) "--no-manual", shQuote(dir)), ignore.stderr=ignore.stderr, intern = TRUE) ## return name of tar file built {plus the build log} : tball <- structure(dir('.', pattern = patt), log3 = r) if(is.null(destdir)) tball else { file.copy(tball, destdir) file.path(destdir, basename(tball)) } } build.pkg("myTst") ## clean up any previous attempt (which might have left a 00LOCK) unlink("myLib", recursive = TRUE) dir.create("myLib") install.packages("myTst", lib = "myLib", repos=NULL, type = "source") # with warnings print(installed.packages(lib.loc= "myLib", priority= "NA"))## (PR#13332) stopifnot(require("myTst",lib = "myLib")) sm <- findMethods(show, where= as.environment("package:myTst")) stopifnot(sm@names == "foo") unlink("myTst_*") ## getPackageName() for "package:foo": require('methods') library(tools) oo <- options(warn=2) detach("package:tools", unload=TRUE) options(oo) ## gave warning (-> Error) about creating package name ## More building & installing packages ## NB: tests were added here for 2.11.0. ## NB^2: do not do this in the R sources (but in a build != src directory!) ## and this testdir is not installed. if(interactive() && Sys.getenv("USER") == "maechler") Sys.setenv(SRCDIR = normalizePath("~/R/D/r-devel/R/tests")) (pkgSrcPath <- file.path(Sys.getenv("SRCDIR"), "Pkgs"))# e.g., -> "../../R/tests/Pkgs" ## SRCDIR not available on windows, so pkgSrcPath won't be populated ## if this happens non-interactively, cleanup and quit gracefully if(!file_test("-d", pkgSrcPath) && !interactive()) { unlink("myTst", recursive=TRUE) showProc.time() q("no") } ## else w/o clause: showProc.time() do.cleanup <- !nzchar(Sys.getenv("R_TESTS_NO_CLEAN")) isWIN <- .Platform$OS.type == "windows" has.symlink <- !isWIN ## Installing "on to" a package existing as symlink in the lib.loc ## -- used to fail with misleading error message (#PR 16725): if(has.symlink && !unlink("myLib_2", recursive=TRUE) && dir.create("myLib_2") && file.rename("myLib/myTst", "myLib_2/myTst") && file.symlink("../myLib_2/myTst", "myLib/myTst")) install.packages("myTst", lib = "myLib", repos=NULL, type = "source") ## In R <= 3.3.2 gave error with *misleading* error message: ## ERROR: ‘myTst’ is not a legal package name if(isWIN) { # (has no symlinks anyway) file.copy(pkgSrcPath, tempdir(), recursive = TRUE) } else { # above file.copy() not useful as it replaces symlink by copy system(paste('cp -R', shQuote(pkgSrcPath), shQuote(tempdir()))) } pkgPath <- file.path(tempdir(), "Pkgs") if(!dir.exists(pkgPath)) { message("No valid 'pkgPath' (from 'pkgSrcPath') - exit this test") if(!interactive()) q("no") } ## pkgB tests an empty R directory dir.create(file.path(pkgPath, "pkgB", "R"), recursive = TRUE, showWarnings = FALSE) ## (how can this happen reliably more easily?) ##' Copy directory d1 to *(newly created |cleaned)* directory d2 -- also with*in* same directory ##' "cp -a d1/ d2/" dirCopy <- function(d1, d2) { stopifnot(exprs = { length(d1) == length(d2) ; length(d1) == 1L dir.exists(d1) dir.exists(D2 <- dirname(d2)) || dir.create(D2, recursive=TRUE) !dir.exists(d2) || unlink(d2, recursive=TRUE) == 0 ## unbelievable contortion just so it works within the *same* directory (really ??) ## 1. copy to *other dir* : dir.create(tD <- tempfile("dirCp")) file.copy(d1, tD, recursive = TRUE) ## 2. correctly "rename" ( i.e., *move*) to "this" dir: file.rename(file.path(tD, basename(d1)), file.path(D2, basename(d2))) }) } ## ## pkgB{2,3} := pkgB but with missing/incomplete 'Imports:' entry in DESCRIPTION pBp <- file.path(pkgPath, "pkgB") dirCopy(pBp, pB2p <- file.path(pkgPath, "pkgB2")) dirCopy(pBp, pB3p <- file.path(pkgPath, "pkgB3")) if(okB2 <- file.exists(DN <- file.path(pB2p, "DESCRIPTION"))) { Dlns <- readLines(DN); i <- grep("^Imports:", Dlns) ## drop 'Imports: ' completely (and replace [Pp]kgB by [Pp]kgB2): writeLines(gsub("kgB", "kgB2", Dlns[-i]), con = DN) } if(okB3 <- file.exists(DN <- file.path(pB3p, "DESCRIPTION"))) { Dlns <- readLines(DN); i <- grep("^Imports:", Dlns) ## Only keep the first 'Imports: ' (and replace [Pp]kgB by [Pp]kgB3): Dlns[i] <- sub(",.*", "", Dlns[i]) writeLines(gsub("kgB", "kgB3", Dlns), con = DN) } ## PR17859.3 := PR17859.2, but with missing '}' in /R/f3.3 : pP2 <- file.path(pkgPath, "PR17859.2"); f2nm <- file.path(pP2, "R", "f3.R") pP3 <- file.path(pkgPath, "PR17859.3"); f3nm <- file.path(pP3, "R", "f3.R") dirCopy(pP2, pP3); DN <- "DESCRIPTION" # --> fix up pkg name writeLines(sub("^(Package: .*)\\.2$", "\\1.3", readLines(file.path(pP2, DN))), file.path(pP3, DN)) f3lns <- f2lns <- readLines(f2nm) iBrace <- grep("closing brace", f2lns, fixed=TRUE) (f3lns[iBrace] <- sub("^", "#> ", f2lns[iBrace])) (writeLines(f3lns, f3nm)) p.fails <- paste0("PR17859.", 1:3) io859 <- c("--no-help", "--no-test-load", "--no-byte-compile") InstOpts <- list("exSexpr" = "--html") for(p in p.fails) InstOpts <- c(InstOpts, `names<-`(list(io859), p)) p.lis <- c(if("Matrix" %in% row.names(installed.packages(.Library))) c("pkgA", "pkgB", if(okB2) "pkgB2", if(okB3) "pkgB3", "pkgC"), "PR17501", p.fails, "exNSS4", "exNSS4nil", "exSexpr") p.lis; (pBlis <- grep("^pkgB", p.lis, value=TRUE)) pkgApath <- file.path(pkgPath, "pkgA") if("pkgA" %in% p.lis && !dir.exists(d <- pkgApath)) { # on Windows, 'pkgA' may end up being a text file with a single line # with a note it is meant to be a link to xDir/pkg cat("symlink 'pkgA' does not exist as directory ",d,"; copying it\n", sep='') unlink(d, recursive=TRUE) dir.create(d) # ensure it is a single existing directory pkgdir <- file.path(pkgPath, "xDir", "pkg") file.copy(file.path(pkgdir, list.files(pkgdir)), to = d, recursive=TRUE) ## if even the copy failed (NB: pkgB, pkgC depend on pkgA) if(!dir.exists(d)) p.lis <- p.lis[!(p.lis %in% c("pkgA", pBlis, "pkgC"))] } dir2pkg <- function(dir) sub("^pkgC", "PkgC", dir) if(is.na(match("myLib", .lP <- .libPaths()))) { .libPaths(c("myLib", .lP)) # PkgC needs pkgA from there .lP <- .libPaths() } Sys.setenv(R_LIBS = .R_LIBS(.lP)) # for build.pkg() & install.packages() showProc.time() for(p in p.lis) { p. <- dir2pkg(p) # 'p' is sub directory name; 'p.' is package name cat("===--===\nFrom pkgPath sub directory", p, " building package", p., "...\n") pkgP <- file.path(pkgPath, p) r <- build.pkg(pkgP, ignore.stderr = (p != "exSexpr")) # 1-2 sec showProc.time() if(!length(r)) # so some sort of failure, show log cat(attr(r, "log3"), sep = "\n") if(!isTRUE(file.exists(r))) stop("R CMD build failed (no tarball) for package ", p.) if(p %in% pBlis) { ## R CMD check "dependencies" res <- tools:::.check_package_depends(dir=pkgP, force_suggest=FALSE) cat("check_package_depends:\n") ; print(res) if(length(res)) pres <- capture.output(res) switch(p , "pkgB" = stopifnot(length(res) == 0) , "pkgB2" = stopifnot(exprs = { length(res) == 1 identical(res$missing_namespace_depends, c("methods", "pkgA")) grepl("Namespace dependencies .* DESCRIPTION" , pres[1]) }) , "pkgB3" = stopifnot(exprs = { length(res) == 1 identical(res[[1]], "pkgA") grepl("Namespace dependency .* DESCRIPTION" , pres[1]) }) ) showProc.time() } else if(p %in% p.fails) { ## NB: Fail with *parse* errors which are *not* tryCatch-able ==> need to call R ## tryCatch(error = identity, ## install.packages(r, lib = "myLib", repos=NULL, type = "source", ## INSTALL_opts = InstOpts[[p.]])) -> err ## cat("tryCatch gave "); dput(err) ## stopifnot(inherits(err, "error")) ## FIXME: do a bit more tf <- tempfile(paste0("regP-inst_",p)) status <- tools:::run_Rcmd(c("INSTALL", r, InstOpts[[p.]]), out=tf, timeout = 10) writeLines(errlns <- readLines(tf)) stopifnot(exprs = { status > 0 # see status == 1L length(iE <- grep("Error in parse(", errlns, fixed=TRUE)) > 0 local({ parseM1 <- "(syntax error|unexpected symbol)" # may depend on bison version parseM2 <- "(syntax error|unexpected end of input)" # (ditto) switch(p , "PR17859.1" = grepl(paste0(p, "/R/f2.R:3:[0-9]+: ", parseM1), errlns[iE+1]) , "PR17859.2" = , "PR17859.3" = grepl(paste0(p, "/R/f2.R:6:0: ", parseM2), errlns[iE+1]) , stop("invalid package p=", p)) }) }) next # pkg in for(...) } ## otherwise install the tar file: cat("installing package", p., "using built file", r, "...\n") ## "FIXME": want to catch warnings in the "console output" of this, ## e.g. exNSS4nil, "S4 exports specified in 'NAMESPACE' but not defined .." install.packages(r, lib = "myLib", repos=NULL, type = "source", INSTALL_opts = InstOpts[[p.]]) stopifnot(require(p., lib = "myLib", character.only=TRUE)) detach(pos = match(p., sub("^package:","", search()))) showProc.time() } cat("\n -------------------end { for(p in p.lis) }----------------------------\n") (res <- installed.packages(lib.loc = "myLib", priority = "NA")) (p.lis <- dir2pkg(setdiff(p.lis, p.fails))) # --> *package* names of installed pkgs stopifnot(exprs = { identical(res[,"Package"], setNames(, sort(c(p.lis, "myTst")))) res[,"LibPath"] == "myLib" }) ### Specific Tests on our "special" packages: ------------------------------ tf <- tempfile("chk_donttest") ## why does this not work (not catch stderr)? textConnection("checkTxt", open="w") system.time(status <- tools:::run_Rcmd(c("check", "PR17501_1.0.tar.gz", "--no-manual"), out = tf, ## avoid delays/timeouts with a broken network route: env = c("R_REPOSITORIES=NULL"), # (no cyclic dep check) timeout = 50))# see 5--7 sec; Solaris needed > 30 stopifnot(exprs = { status == 1 # an ERROR now is.character(exLines <- readLines(file.path("PR17501.Rcheck", "PR17501-Ex.R"))) { str(exLines); length(exLines) > 20 } # str(): diagnostic in case is.integer(i <- grep("^R\\.Version\\( *# missing closing paren", exLines)) grepl("^## No test", exLines[i-1]) { str(tlines <- readLines(tf)); length(tlines) > 20 } length(iw <- grep("^Warning: parse error", tlines)) == 1 (lenN <- length(print(iN <- grep("^[1-9][0-9]:", tlines)))) >= 2 iN - iw == seq_len(lenN) # these (3) lines come immediately after 'Warning', ## and "related" to the some 'missing .. paren' above: !is.na(ierr <- as.integer(substr(print(tlines[iN[1]]), 1, 2))) 8 <= print(ierr - i) & ierr - i <= 14 # see 11 }) ## failed in R <= 4.1.1 ## These used to fail because of the sym.link in pkgA if("pkgA" %in% p.lis && dir.exists(pkgApath)) { cat("undoc(pkgA):\n"); print(uA <- tools::undoc(dir = pkgApath)) cat("codoc(pkgA):\n"); print(cA <- tools::codoc(dir = pkgApath)) cat("extends(\"classApp\"):\n"); print(ext.cA <- extends("classApp")) stopifnot(exprs = { identical(uA$`code objects`, c("nil", "search")) identical(uA$`data sets`, "nilData") ## pkgC's class union is now (after loading pkgC) also visible in the "classApp" subclass ## (which gave warning). ==> warning "wrong": somehow it *did* get updated: "numericA" %in% ext.cA }) } else message("'pkgA' not available") showProc.time() ## - Check conflict message. ## - Find objects which are NULL via "::" -- not to be expected often ## we have one in our pkgA, but only if Matrix is present. if(dir.exists(file.path("myLib", "pkgA"))) { msgs <- capture.output(require(pkgA, lib="myLib"), type = "message") writeLines(msgs) stopifnot(length(msgs) > 2, length(grep("The following object is masked.*package:base", msgs)) > 0, length(grep("\\bsearch\\b", msgs)) > 0) data(package = "pkgA") # -> nilData stopifnot(is.null( pkgA:: nil), is.null( pkgA::: nil), is.null( pkgA:: nilData)) # <- ## R-devel (pre 3.2.0) wrongly errored for NULL lazy data ## ::: does not apply to data sets: tools::assertError(is.null(pkgA:::nilData)) } else message("'pkgA' not in 'myLib'") showProc.time() ## Check error from invalid logical field in DESCRIPTION: (okA <- ("pkgA" %in% p.lis) && dir.exists(pkgApath) && file.exists(DN <- file.path(pkgApath, "DESCRIPTION"))) if(okA) { Dlns <- readLines(DN); i <- grep("^LazyData:", Dlns) Dlns[i] <- paste0(Dlns[i], ",") ## adding a "," writeLines(Dlns, con = DN) ## do not test installation failure in myLib as previous pkgA would be removed ## from there (because no.q=TRUE causes do_exit_on_error() to be called twice) ## and if getNamespaceInfo("pkgA", "path") no longer exists, ## sessionInfo() fails in the "exSexpr" test below instEXPR <- quote( tools:::.install_packages(c("--clean", paste0("--library=", tempdir()), pkgApath), no.q = TRUE) ) ## ----------------- ---- if(interactive()) { ## << "FIXME!" This (sink(.) ..) fails, when run via 'make'. ## install.packages() should give "the correct" error but we cannot catch it ## One level lower is not much better, needing sink() as capture.output() fails ftf <- file(tf <- tempfile("inst_pkg"), open = "wt") sink(ftf); sink(ftf, type = "message")# "message" should be sufficient eval(instEXPR) sink(type="message"); sink()## ; close(ftf); rm(ftf)# end sink() writeLines(paste(" ", msgs <- readLines(tf))) message(err <- grep("^ERROR:", msgs, value=TRUE)) stopifnot(exprs = { length(err) > 0 grepl("invalid .*LazyData .*DESCRIPTION", err) }) } else { message("non-interactive -- tools:::.install_packages(..) : ") try( eval(instEXPR) ) # showing the error message in the *.Rout file } } else message("pkgA/DESCRIPTION not available") showProc.time() ## R CMD check should *not* warn about \Sexpr{} built sections in Rd (PR#17479): msg <- capture.output( tools:::.check_package_parseRd(dir=file.path(pkgPath, "exSexpr"))) if(length(msg)) stop(".check_package_parseRd() gave message\n",msg) ## in R <= 3.5.1, gave ## "prepare_Rd: foo.Rd:14: Section \\Sexpr is unrecognized and will be dropped" showProc.time() if(dir.exists(file.path("myLib", "exNSS4"))) withAutoprint({ require("exNSS4", lib="myLib") validObject(dd <- new("ddiM")) print(is(dd)) # 5 of them .. writeLines(myGmeth <- capture.output(show(exNSS4:::myGenf))) stopifnot(exprs = { is(dd, "mM") inherits(dd, "mM") grepl("showMethods(exNSS4:::myGenf)", myGmeth[length(myGmeth)], fixed=TRUE) }) ## tests here should *NOT* assume recommended packages, ## let alone where they are installed if(dir.exists(file.path(.Library, "Matrix"))) { for(ns in c(rev(p.lis), "Matrix")) unloadNamespace(ns) ## Both exNSS4 and Matrix define "atomicVector" *the same*, ## but 'exNSS4' has it extended - and hence *both* are registered in cache -> "conflicts" requireNamespace("exNSS4", lib= "myLib") ## Found in cache, since there is only one definition. ## Might confuse users. stopifnot(isVirtualClass(getClass("atomicVector"))) requireNamespace("Matrix", lib= .Library) ## Throws an error, because there is ambiguity in the cache, ## and the dynamic search will not find anything, since the packages ## are not attached. tools::assertCondition( acl <- getClass("atomicVector") ) ## Once Matrix is attached, we find a unique definition. library(Matrix) stopifnot(isVirtualClass(getClass("atomicVector"))) } }) showProc.time() ## Part 3: repository construction --------------------------------------------- ## test tools::write_PACKAGES and tools::update_PACKAGES oldpkgdir <- file.path(tempdir(), "pkgfiles/old") newpkgdir <- file.path(tempdir(), "pkgfiles/new") repodir <- file.path(tempdir(), "pkgrepo") dir.create(oldpkgdir, recursive = TRUE) dir.create(newpkgdir) if(file.exists(repodir)) unlink(repodir, recursive = TRUE) dir.create(repodir) ro <- build.pkg(file.path(pkgPath, c("pkgD", "pkgB")), oldpkgdir) rn <- build.pkg(file.path(pkgPath, c("pkgD_2", "pkgD_3")), newpkgdir) unlist(ro) unlist(rn) ##' A repo package database in directory 'dir' mkPkgfiles <- function(dir) file.path(dir, c("PACKAGES", "PACKAGES.gz", "PACKAGES.rds")) ##' safe read.dcf() read.safe.dcf <- function(f) if(file.exists(f)) read.dcf(f) # else NULL ## this will fail with an error if write_PACKAGES ## and update_PACKAGES do not generate the same ## PACKAGE file entries, in the same order, with ## the same field order. docompare <- function(..., repdir = repodir, strict = TRUE) { Pfiles <- mkPkgfiles(repdir) backupPfiles <- file.path(tempdir(), basename(Pfiles)) indfile <- Pfiles[1] ## vvvvvvvvvvvvvvv tools::write_PACKAGES(repdir, type = "source", ...) wpres <- read.safe.dcf(indfile) # write_P result ## reset the PACKAGES files so that update_PACKAGES thinks any deviations are "new" if(all(file.exists(backupPfiles))) file.copy(backupPfiles, Pfiles, overwrite = TRUE) ## vvvvvvvvvvvvvvv tools::update_PACKAGES(repdir, type = "source", strict=strict, ...) upres <- read.safe.dcf(indfile) # update_P result stopifnot(identical(wpres, upres)) } Pfiles <- mkPkgfiles(repodir) backupPfiles <- file.path(tempdir(), basename(Pfiles)) if(all(file.exists(backupPfiles))) unlink(backupPfiles) showProc.time() ## test write_PACKAGES and update_PACKAGES ## on empty dir ## IGNORE_RDIFF_BEGIN docompare() ## one warning expected, has a temp path in it so ignore diff ## IGNORE_RDIFF_END oldpfs <- list.files(oldpkgdir, pattern = "\\.tar\\.gz$", recursive = TRUE, full.names = TRUE) newpfs <- list.files(newpkgdir, pattern = "\\.tar\\.gz$", recursive = TRUE, full.names = TRUE) ## generate and backup "original repo state" file.copy(oldpfs, to = repodir) tools::write_PACKAGES(repodir, type = "source") file.copy(Pfiles, backupPfiles, overwrite = TRUE) showProc.time() ## test update_PACKAGES with no change docompare() ## all old files gone, new files present unlink(file.path(repodir, basename(oldpfs))) file.copy(newpfs, to = repodir) docompare() docompare(strict=FALSE) ## put old ones back file.copy(oldpfs, to = repodir) showProc.time() if(isWIN){ nrepodir <- normalizePath(repodir) if(grepl("^\\\\", nrepodir)) #\\laptop\whatever repourl <- paste0("file:", gsub("\\\\", "/", nrepodir)) else #C:\whatever repourl <- paste0("file:///", gsub("\\\\", "/", nrepodir)) } else repourl <- paste0("file://", normalizePath(repodir)) ## make sure the ordering is right when ## old and new entries are mixed in final db ## ##' care: stopifnot(nrow(1) == 2) # does *not* trigger checkMatrix <- function(x, n) stopifnot(is.matrix(x), nrow(x) == n) docompare(latestOnly = TRUE) str(ap <- available.packages(repourl, filters = list())) checkMatrix(ap, 2) docompare(latestOnly = FALSE) str(ap <- available.packages(repourl, filters = list())) checkMatrix(ap, 4) docompare(latestOnly = TRUE, strict = FALSE) str(ap <- available.packages(repourl, filters = list())) checkMatrix(ap, 2) docompare(latestOnly = FALSE, strict = FALSE) str(ap <- available.packages(repourl, filters = list())) checkMatrix(ap, 4) ## clean up rmL <- c("myLib", if(has.symlink) "myLib_2", "myTst", "myTst2", "PR17501.Rcheck") if(do.cleanup) { for(nm in rmL) unlink(nm, recursive = TRUE) } else { cat("Not cleaning, i.e., keeping ", paste(rmL, collapse=", "), "\n") } showProc.time() ## And the final: environment(showProc.time)[["pct"]]