From 15072099bc37c2fa677914b236f77f793cd7b74e Mon Sep 17 00:00:00 2001
From: Michael Chirico <michael.chirico@grabtaxi.com>
Date: Fri, 13 Mar 2020 14:31:08 +0800
Subject: [PATCH 01/23] add whitespace to remove spurious coverage of inlined
 src/ error branches

---
 src/assign.c       |  93 ++++++++++++++++++++-----------
 src/bmerge.c       |  48 ++++++++++------
 src/dogroups.c     |  54 ++++++++++++------
 src/fcast.c        |   3 +-
 src/fmelt.c        |  66 ++++++++++++++--------
 src/forder.c       |  18 ++++--
 src/frank.c        |  15 +++--
 src/freadR.c       |   6 +-
 src/fsort.c        |  12 ++--
 src/fwriteR.c      |   6 +-
 src/gsumm.c        | 135 ++++++++++++++++++++++++++++++---------------
 src/ijoin.c        |  33 +++++++----
 src/init.c         |  93 ++++++++++++++++++++-----------
 src/nafill.c       |   3 +-
 src/openmp-utils.c |  12 ++--
 src/rbindlist.c    |  50 +++++++++++------
 src/reorder.c      |  12 ++--
 src/shift.c        |  11 +++-
 src/subset.c       |  33 +++++++----
 src/uniqlist.c     |  42 +++++++++-----
 src/utils.c        |   5 +-
 src/vecseq.c       |  18 ++++--
 src/wrappers.c     |  15 +++--
 23 files changed, 523 insertions(+), 260 deletions(-)

diff --git a/src/assign.c b/src/assign.c
index 1392079e72..bb1d929e51 100644
--- a/src/assign.c
+++ b/src/assign.c
@@ -4,12 +4,15 @@ static void finalizer(SEXP p)
 {
   SEXP x;
   R_len_t n, l, tl;
-  if(!R_ExternalPtrAddr(p)) error(_("Internal error: finalizer hasn't received an ExternalPtr")); // # nocov
+  if(!R_ExternalPtrAddr(p))
+    error(_("Internal error: finalizer hasn't received an ExternalPtr")); // # nocov
   p = R_ExternalPtrTag(p);
-  if (!isString(p)) error(_("Internal error: finalizer's ExternalPtr doesn't see names in tag")); // # nocov
+  if (!isString(p))
+    error(_("Internal error: finalizer's ExternalPtr doesn't see names in tag")); // # nocov
   l = LENGTH(p);
   tl = TRUELENGTH(p);
-  if (l<0 || tl<l) error(_("Internal error: finalizer sees l=%d, tl=%d"),l,tl); // # nocov
+  if (l<0 || tl<l)
+    error(_("Internal error: finalizer sees l=%d, tl=%d"),l,tl); // # nocov
   n = tl-l;
   if (n==0) {
     // gc's ReleaseLargeFreeVectors() will have reduced R_LargeVallocSize by the correct amount
@@ -121,9 +124,11 @@ static int _selfrefok(SEXP x, Rboolean checkNames, Rboolean verbose) {
     if (verbose) Rprintf(_(".internal.selfref ptr is NULL. This is expected and normal for a data.table loaded from disk. Please remember to always setDT() immediately after loading to prevent unexpected behavior. If this table was not loaded from disk or you've already run setDT(), please report to data.table issue tracker.\n"));
     return -1;
   }
-  if (!isNull(p)) error(_("Internal error: .internal.selfref ptr is not NULL or R_NilValue")); // # nocov
+  if (!isNull(p))
+    error(_("Internal error: .internal.selfref ptr is not NULL or R_NilValue")); // # nocov
   tag = R_ExternalPtrTag(v);
-  if (!(isNull(tag) || isString(tag))) error(_("Internal error: .internal.selfref tag isn't NULL or a character vector")); // # nocov
+  if (!(isNull(tag) || isString(tag)))
+    error(_("Internal error: .internal.selfref tag isn't NULL or a character vector")); // # nocov
   names = getAttrib(x, R_NamesSymbol);
   if (names != tag && isString(names))
     SET_TRUELENGTH(names, LENGTH(names));
@@ -165,7 +170,8 @@ static SEXP shallow(SEXP dt, SEXP cols, R_len_t n)
     l = LENGTH(dt);
     for (i=0; i<l; i++) SET_VECTOR_ELT(newdt, i, VECTOR_ELT(dt,i));
     if (length(names)) {
-      if (length(names) < l) error(_("Internal error: length(names)>0 but <length(dt)")); // # nocov
+      if (length(names) < l)
+        error(_("Internal error: length(names)>0 but <length(dt)")); // # nocov
       for (i=0; i<l; i++) SET_STRING_ELT(newnames, i, STRING_ELT(names,i));
     }
     // else an unnamed data.table is valid e.g. unname(DT) done by ggplot2, and .SD may have its names cleared in dogroups, but shallow will always create names for data.table(NULL) which has 100 slots all empty so you can add to an empty data.table by reference ok.
@@ -194,15 +200,19 @@ SEXP alloccol(SEXP dt, R_len_t n, Rboolean verbose)
 {
   SEXP names, klass;   // klass not class at request of pydatatable because class is reserved word in C++, PR #3129
   R_len_t l, tl;
-  if (isNull(dt)) error(_("alloccol has been passed a NULL dt"));
-  if (TYPEOF(dt) != VECSXP) error(_("dt passed to alloccol isn't type VECSXP"));
+  if (isNull(dt))
+    error(_("alloccol has been passed a NULL dt"));
+  if (TYPEOF(dt) != VECSXP)
+    error(_("dt passed to alloccol isn't type VECSXP"));
   klass = getAttrib(dt, R_ClassSymbol);
-  if (isNull(klass)) error(_("dt passed to alloccol has no class attribute. Please report result of traceback() to data.table issue tracker."));
+  if (isNull(klass))
+    error(_("dt passed to alloccol has no class attribute. Please report result of traceback() to data.table issue tracker."));
   l = LENGTH(dt);
   names = getAttrib(dt,R_NamesSymbol);
   // names may be NULL when null.data.table() passes list() to alloccol for example.
   // So, careful to use length() on names, not LENGTH().
-  if (length(names)!=l) error(_("Internal error: length of names (%d) is not length of dt (%d)"),length(names),l); // # nocov
+  if (length(names)!=l)
+    error(_("Internal error: length of names (%d) is not length of dt (%d)"),length(names),l); // # nocov
   if (!selfrefok(dt,verbose))
     return shallow(dt,R_NilValue,(n>l) ? n : l);  // e.g. test 848 and 851 in R > 3.0.2
     // added (n>l) ? ... for #970, see test 1481.
@@ -212,8 +222,10 @@ SEXP alloccol(SEXP dt, R_len_t n, Rboolean verbose)
 
   tl = TRUELENGTH(dt);
   // R <= 2.13.2 and we didn't catch uninitialized tl somehow
-  if (tl<0) error(_("Internal error, tl of class is marked but tl<0.")); // # nocov
-  if (tl>0 && tl<l) error(_("Internal error, please report (including result of sessionInfo()) to data.table issue tracker: tl (%d) < l (%d) but tl of class is marked."), tl, l); // # nocov
+  if (tl<0)
+    error(_("Internal error, tl of class is marked but tl<0.")); // # nocov
+  if (tl>0 && tl<l)
+    error(_("Internal error, please report (including result of sessionInfo()) to data.table issue tracker: tl (%d) < l (%d) but tl of class is marked."), tl, l); // # nocov
   if (tl>l+10000) warning(_("tl (%d) is greater than 10,000 items over-allocated (l = %d). If you didn't set the datatable.alloccol option to be very large, please report to data.table issue tracker including the result of sessionInfo()."),tl,l);
   if (n>tl) return(shallow(dt,R_NilValue,n)); // usual case (increasing alloc)
   if (n<tl && verbose) Rprintf(_("Attempt to reduce allocation from %d to %d ignored. Can only increase allocation via shallow copy. Please do not use DT[...]<- or DT$someCol<-. Use := inside DT[...] instead."),tl,n);
@@ -236,7 +248,8 @@ int checkOverAlloc(SEXP x)
 }
 
 SEXP alloccolwrapper(SEXP dt, SEXP overAllocArg, SEXP verbose) {
-  if (!isLogical(verbose) || length(verbose)!=1) error(_("verbose must be TRUE or FALSE"));
+  if (!isLogical(verbose) || length(verbose)!=1)
+    error(_("verbose must be TRUE or FALSE"));
   int overAlloc = checkOverAlloc(overAllocArg);
   SEXP ans = PROTECT(alloccol(dt, length(dt)+overAlloc, LOGICAL(verbose)[0]));
 
@@ -284,8 +297,10 @@ SEXP assign(SEXP dt, SEXP rows, SEXP cols, SEXP newcolnames, SEXP values)
   int ndelete=0;  // how many columns are being deleted
   const char *c1, *tc1, *tc2;
   int *buf, newKeyLength, indexNo;
-  if (isNull(dt)) error(_("assign has been passed a NULL dt"));
-  if (TYPEOF(dt) != VECSXP) error(_("dt passed to assign isn't type VECSXP"));
+  if (isNull(dt))
+    error(_("assign has been passed a NULL dt"));
+  if (TYPEOF(dt) != VECSXP)
+    error(_("dt passed to assign isn't type VECSXP"));
   if (islocked(dt))
     error(_(".SD is locked. Updating .SD by reference using := or set are reserved for future use. Use := in j directly. Or use copy(.SD) as a (slow) last resort, until shallow() is exported."));
 
@@ -299,7 +314,8 @@ SEXP assign(SEXP dt, SEXP rows, SEXP cols, SEXP newcolnames, SEXP values)
 
   oldncol = LENGTH(dt);
   SEXP names = PROTECT(getAttrib(dt, R_NamesSymbol)); protecti++;
-  if (isNull(names)) error(_("dt passed to assign has no names"));
+  if (isNull(names))
+    error(_("dt passed to assign has no names"));
   if (length(names)!=oldncol)
     error(_("Internal error in assign: length of names (%d) is not length of dt (%d)"),length(names),oldncol); // # nocov
   if (isNull(dt)) {
@@ -356,7 +372,8 @@ SEXP assign(SEXP dt, SEXP rows, SEXP cols, SEXP newcolnames, SEXP values)
       if (INTEGER(tmp)[i] == 0) buf[k++] = i;
     }
     if (k>0) {
-      if (!isDataTable) error(_("set() on a data.frame is for changing existing columns, not adding new ones. Please use a data.table for that. data.table's are over-allocated and don't shallow copy."));
+      if (!isDataTable)
+        error(_("set() on a data.frame is for changing existing columns, not adding new ones. Please use a data.table for that. data.table's are over-allocated and don't shallow copy."));
       newcolnames = PROTECT(allocVector(STRSXP, k)); protecti++;
       for (i=0; i<k; i++) {
         SET_STRING_ELT(newcolnames, i, STRING_ELT(cols, buf[i]));
@@ -372,8 +389,10 @@ SEXP assign(SEXP dt, SEXP rows, SEXP cols, SEXP newcolnames, SEXP values)
     if (!isInteger(cols))
       error(_("j is type '%s'. Must be integer, character, or numeric is coerced with warning."), type2char(TYPEOF(cols)));
   }
-  if (any_duplicated(cols,FALSE)) error(_("Can't assign to the same column twice in the same query (duplicates detected)."));
-  if (!isNull(newcolnames) && !isString(newcolnames)) error(_("newcolnames is supplied but isn't a character vector"));
+  if (any_duplicated(cols,FALSE))
+    error(_("Can't assign to the same column twice in the same query (duplicates detected)."));
+  if (!isNull(newcolnames) && !isString(newcolnames))
+    error(_("newcolnames is supplied but isn't a character vector"));
   bool RHS_list_of_columns = TYPEOF(values)==VECSXP && length(cols)>1;  // initial value; may be revised below
   if (verbose) Rprintf(_("RHS_list_of_columns == %s\n"), RHS_list_of_columns ? "true" : "false");
   if (TYPEOF(values)==VECSXP && length(cols)==1 && length(values)==1) {
@@ -400,13 +419,16 @@ SEXP assign(SEXP dt, SEXP rows, SEXP cols, SEXP newcolnames, SEXP values)
   for (i=0; i<length(cols); i++) {
     coln = INTEGER(cols)[i];
     if (coln<1 || coln>oldncol+length(newcolnames)) {
-      if (!isDataTable) error(_("Item %d of column numbers in j is %d which is outside range [1,ncol=%d]. set() on a data.frame is for changing existing columns, not adding new ones. Please use a data.table for that."), i+1, coln, oldncol);
-      else error(_("Item %d of column numbers in j is %d which is outside range [1,ncol=%d]. Use column names instead in j to add new columns."), i+1, coln, oldncol);
+      if (!isDataTable)
+        error(_("Item %d of column numbers in j is %d which is outside range [1,ncol=%d]. set() on a data.frame is for changing existing columns, not adding new ones. Please use a data.table for that."), i+1, coln, oldncol);
+      else
+        error(_("Item %d of column numbers in j is %d which is outside range [1,ncol=%d]. Use column names instead in j to add new columns."), i+1, coln, oldncol);
     }
     coln--;
     SEXP thisvalue = RHS_list_of_columns ? VECTOR_ELT(values, i) : values;
     vlen = length(thisvalue);
-    if (isNull(thisvalue) && !isNull(rows)) error(_("When deleting columns, i should not be provided"));  // #1082, #3089
+    if (isNull(thisvalue) && !isNull(rows))
+      error(_("When deleting columns, i should not be provided"));  // #1082, #3089
     if (coln+1 <= oldncol) colnam = STRING_ELT(names,coln);
     else colnam = STRING_ELT(newcolnames,coln-length(names));
     if (coln+1 <= oldncol && isNull(thisvalue)) continue;  // delete existing column(s) afterwards, near end of this function
@@ -444,7 +466,8 @@ SEXP assign(SEXP dt, SEXP rows, SEXP cols, SEXP newcolnames, SEXP values)
     oldtncol = TRUELENGTH(dt);   // TO DO: oldtncol can be just called tl now, as we won't realloc here any more.
 
     if (oldtncol<oldncol) {
-      if (oldtncol==0) error(_("This data.table has either been loaded from disk (e.g. using readRDS()/load()) or constructed manually (e.g. using structure()). Please run setDT() or setalloccol() on it first (to pre-allocate space for new columns) before assigning by reference to it."));   // #2996
+      if (oldtncol==0)
+        error(_("This data.table has either been loaded from disk (e.g. using readRDS()/load()) or constructed manually (e.g. using structure()). Please run setDT() or setalloccol() on it first (to pre-allocate space for new columns) before assigning by reference to it."));   // #2996
       error(_("Internal error: oldtncol(%d) < oldncol(%d). Please report to data.table issue tracker, including result of sessionInfo()."), oldtncol, oldncol); // # nocov
     }
     if (oldtncol>oldncol+10000L) warning(_("truelength (%d) is greater than 10,000 items over-allocated (length = %d). See ?truelength. If you didn't set the datatable.alloccol option very large, please report to data.table issue tracker including the result of sessionInfo()."),oldtncol, oldncol);
@@ -466,7 +489,8 @@ SEXP assign(SEXP dt, SEXP rows, SEXP cols, SEXP newcolnames, SEXP values)
     coln = INTEGER(cols)[i]-1;
     SEXP thisvalue = RHS_list_of_columns ? VECTOR_ELT(values, i) : values;
     if (TYPEOF(thisvalue)==NILSXP) {
-      if (!isNull(rows)) error(_("Internal error: earlier error 'When deleting columns, i should not be provided' did not happen.")); // # nocov
+      if (!isNull(rows))
+        error(_("Internal error: earlier error 'When deleting columns, i should not be provided' did not happen.")); // # nocov
       ndelete++;
       continue;   // delete column(s) afterwards, below this loop
     }
@@ -559,7 +583,8 @@ SEXP assign(SEXP dt, SEXP rows, SEXP cols, SEXP newcolnames, SEXP values)
         continue; // with next index
       }
       tc1 += 2; // tc1 always marks the start of a key column
-      if (!*tc1) error(_("Internal error: index name ends with trailing __")); // # nocov
+      if (!*tc1)
+        error(_("Internal error: index name ends with trailing __")); // # nocov
       // check the position of the first appearance of an assigned column in the index.
       // the new index will be truncated to this position.
       char *s4 = (char*) malloc(strlen(c1) + 3);
@@ -810,7 +835,8 @@ const char *memrecycle(const SEXP target, const SEXP where, const int start, con
             SEXP s = sourceLevelsD[k];
             int tl = TRUELENGTH(s);
             if (tl) {  // tl negative here
-              if (tl != -nTargetLevels-thisAdd-1) error(_("Internal error: extra level check sum failed")); // # nocov
+              if (tl != -nTargetLevels-thisAdd-1)
+                error(_("Internal error: extra level check sum failed")); // # nocov
               temp[thisAdd++] = s;
               SET_TRUELENGTH(s,0);
             }
@@ -1204,13 +1230,18 @@ void savetl_end() {
 SEXP setcharvec(SEXP x, SEXP which, SEXP newx)
 {
   int w;
-  if (!isString(x)) error(_("x must be a character vector"));
-  if (!isInteger(which)) error(_("'which' must be an integer vector"));
-  if (!isString(newx)) error(_("'new' must be a character vector"));
-  if (LENGTH(newx)!=LENGTH(which)) error(_("'new' is length %d. Should be the same as length of 'which' (%d)"),LENGTH(newx),LENGTH(which));
+  if (!isString(x))
+    error(_("x must be a character vector"));
+  if (!isInteger(which))
+    error(_("'which' must be an integer vector"));
+  if (!isString(newx))
+    error(_("'new' must be a character vector"));
+  if (LENGTH(newx)!=LENGTH(which))
+    error(_("'new' is length %d. Should be the same as length of 'which' (%d)"),LENGTH(newx),LENGTH(which));
   for (int i=0; i<LENGTH(which); i++) {
     w = INTEGER(which)[i];
-    if (w==NA_INTEGER || w<1 || w>LENGTH(x)) error(_("Item %d of 'which' is %d which is outside range of the length %d character vector"), i+1,w,LENGTH(x));
+    if (w==NA_INTEGER || w<1 || w>LENGTH(x))
+      error(_("Item %d of 'which' is %d which is outside range of the length %d character vector"), i+1,w,LENGTH(x));
     SET_STRING_ELT(x, w-1, STRING_ELT(newx, i));
   }
   return R_NilValue;
diff --git a/src/bmerge.c b/src/bmerge.c
index 15d7d6f4f7..0895d287f6 100644
--- a/src/bmerge.c
+++ b/src/bmerge.c
@@ -45,33 +45,44 @@ SEXP bmerge(SEXP iArg, SEXP xArg, SEXP icolsArg, SEXP xcolsArg, SEXP isorted, SE
 
   // iArg, xArg, icolsArg and xcolsArg
   i = iArg; x = xArg;  // set globals so bmerge_r can see them.
-  if (!isInteger(icolsArg)) error(_("Internal error: icols is not integer vector")); // # nocov
-  if (!isInteger(xcolsArg)) error(_("Internal error: xcols is not integer vector")); // # nocov
-  if (LENGTH(icolsArg) > LENGTH(xcolsArg)) error(_("Internal error: length(icols) [%d] > length(xcols) [%d]"), LENGTH(icolsArg), LENGTH(xcolsArg)); // # nocov
+  if (!isInteger(icolsArg))
+    error(_("Internal error: icols is not integer vector")); // # nocov
+  if (!isInteger(xcolsArg))
+    error(_("Internal error: xcols is not integer vector")); // # nocov
+  if (LENGTH(icolsArg) > LENGTH(xcolsArg))
+    error(_("Internal error: length(icols) [%d] > length(xcols) [%d]"), LENGTH(icolsArg), LENGTH(xcolsArg)); // # nocov
   icols = INTEGER(icolsArg);
   xcols = INTEGER(xcolsArg);
   xN = LENGTH(x) ? LENGTH(VECTOR_ELT(x,0)) : 0;
   iN = ilen = anslen = LENGTH(i) ? LENGTH(VECTOR_ELT(i,0)) : 0;
   ncol = LENGTH(icolsArg);    // there may be more sorted columns in x than involved in the join
   for(int col=0; col<ncol; col++) {
-    if (icols[col]==NA_INTEGER) error(_("Internal error. icols[%d] is NA"), col); // # nocov
-    if (xcols[col]==NA_INTEGER) error(_("Internal error. xcols[%d] is NA"), col); // # nocov
-    if (icols[col]>LENGTH(i) || icols[col]<1) error(_("icols[%d]=%d outside range [1,length(i)=%d]"), col, icols[col], LENGTH(i));
-    if (xcols[col]>LENGTH(x) || xcols[col]<1) error(_("xcols[%d]=%d outside range [1,length(x)=%d]"), col, xcols[col], LENGTH(x));
+    if (icols[col]==NA_INTEGER)
+      error(_("Internal error. icols[%d] is NA"), col); // # nocov
+    if (xcols[col]==NA_INTEGER)
+      error(_("Internal error. xcols[%d] is NA"), col); // # nocov
+    if (icols[col]>LENGTH(i) || icols[col]<1)
+      error(_("icols[%d]=%d outside range [1,length(i)=%d]"), col, icols[col], LENGTH(i));
+    if (xcols[col]>LENGTH(x) || xcols[col]<1)
+      error(_("xcols[%d]=%d outside range [1,length(x)=%d]"), col, xcols[col], LENGTH(x));
     int it = TYPEOF(VECTOR_ELT(i, icols[col]-1));
     int xt = TYPEOF(VECTOR_ELT(x, xcols[col]-1));
-    if (iN && it!=xt) error(_("typeof x.%s (%s) != typeof i.%s (%s)"), CHAR(STRING_ELT(getAttrib(x,R_NamesSymbol),xcols[col]-1)), type2char(xt), CHAR(STRING_ELT(getAttrib(i,R_NamesSymbol),icols[col]-1)), type2char(it));
+    if (iN && it!=xt)
+      error(_("typeof x.%s (%s) != typeof i.%s (%s)"), CHAR(STRING_ELT(getAttrib(x,R_NamesSymbol),xcols[col]-1)), type2char(xt), CHAR(STRING_ELT(getAttrib(i,R_NamesSymbol),icols[col]-1)), type2char(it));
   }
   // raise(SIGINT);
 
   // rollArg, rollendsArg
   roll = 0.0; rollToNearest = FALSE;
   if (isString(rollarg)) {
-    if (strcmp(CHAR(STRING_ELT(rollarg,0)),"nearest") != 0) error(_("roll is character but not 'nearest'"));
-    if (TYPEOF(VECTOR_ELT(i, icols[ncol-1]-1))==STRSXP) error(_("roll='nearest' can't be applied to a character column, yet."));
+    if (strcmp(CHAR(STRING_ELT(rollarg,0)),"nearest") != 0)
+      error(_("roll is character but not 'nearest'"));
+    if (TYPEOF(VECTOR_ELT(i, icols[ncol-1]-1))==STRSXP)
+      error(_("roll='nearest' can't be applied to a character column, yet."));
     roll=1.0; rollToNearest=TRUE;       // the 1.0 here is just any non-0.0, so roll!=0.0 can be used later
   } else {
-    if (!isReal(rollarg)) error(_("Internal error: roll is not character or double")); // # nocov
+    if (!isReal(rollarg))
+      error(_("Internal error: roll is not character or double")); // # nocov
     roll = REAL(rollarg)[0];   // more common case (rolling forwards or backwards) or no roll when 0.0
   }
   rollabs = fabs(roll);
@@ -153,7 +164,8 @@ SEXP bmerge(SEXP iArg, SEXP xArg, SEXP icolsArg, SEXP xcolsArg, SEXP isorted, SE
   // xo arg
   xo = NULL;
   if (length(xoArg)) {
-    if (!isInteger(xoArg)) error(_("Internal error: xoArg is not an integer vector")); // # nocov
+    if (!isInteger(xoArg))
+      error(_("Internal error: xoArg is not an integer vector")); // # nocov
     xo = INTEGER(xoArg);
   }
 
@@ -268,7 +280,8 @@ void bmerge_r(int xlowIn, int xuppIn, int ilowIn, int iuppIn, int col, int thisg
       case LT : xupp = xlow + 1; xlow = xlowIn; break;
       case GE : if (ival.i != NA_INTEGER) xupp = xuppIn; break;
       case GT : xlow = xupp - 1; if (ival.i != NA_INTEGER) xupp = xuppIn; break;
-      default : error(_("Internal error in bmerge_r for '%s' column. Unrecognized value op[col]=%d"), type2char(TYPEOF(xc)), op[col]); // #nocov
+      default :
+        error(_("Internal error in bmerge_r for '%s' column. Unrecognized value op[col]=%d"), type2char(TYPEOF(xc)), op[col]); // #nocov
       }
       // for LE/LT cases, we need to ensure xlow excludes NA indices, != EQ is checked above already
       if (op[col] <= 3 && xlow<xupp-1 && ival.i != NA_INTEGER && INTEGER(xc)[XIND(xlow+1)] == NA_INTEGER) {
@@ -300,7 +313,8 @@ void bmerge_r(int xlowIn, int xuppIn, int ilowIn, int iuppIn, int col, int thisg
   }
     break;
   case STRSXP : {
-    if (op[col] != EQ) error(_("Only '==' operator is supported for columns of type %s."), type2char(TYPEOF(xc)));
+    if (op[col] != EQ)
+      error(_("Only '==' operator is supported for columns of type %s."), type2char(TYPEOF(xc)));
     ival.s = ENC2UTF8(STRING_ELT(ic,ir));
     while(xlow < xupp-1) {
       int mid = xlow + (xupp-xlow)/2;
@@ -376,7 +390,8 @@ void bmerge_r(int xlowIn, int xuppIn, int ilowIn, int iuppIn, int col, int thisg
       case LT : xupp = xlow + 1; if (!isivalNA) xlow = xlowIn; break;
       case GE : if (!isivalNA) xupp = xuppIn; break;
       case GT : xlow = xupp - 1; if (!isivalNA) xupp = xuppIn; break;
-      default : error(_("Internal error in bmerge_r for '%s' column. Unrecognized value op[col]=%d"), type2char(TYPEOF(xc)), op[col]); // #nocov
+      default :
+        error(_("Internal error in bmerge_r for '%s' column. Unrecognized value op[col]=%d"), type2char(TYPEOF(xc)), op[col]); // #nocov
       }
       // for LE/LT cases, we need to ensure xlow excludes NA indices, != EQ is checked above already
       if (op[col] <= 3 && xlow<xupp-1 && !isivalNA && (!isInt64 ? ISNAN(dxc[XIND(xlow+1)]) : (DtoLL(dxc[XIND(xlow+1)]) == NA_INT64_LL))) {
@@ -465,7 +480,8 @@ void bmerge_r(int xlowIn, int xuppIn, int ilowIn, int iuppIn, int col, int thisg
     }
   } else if (roll!=0.0 && col==ncol-1) {
     // runs once per i row (not each search test), so not hugely time critical
-    if (xlow != xupp-1 || xlow<xlowIn || xupp>xuppIn) error(_("Internal error: xlow!=xupp-1 || xlow<xlowIn || xupp>xuppIn")); // # nocov
+    if (xlow != xupp-1 || xlow<xlowIn || xupp>xuppIn)
+      error(_("Internal error: xlow!=xupp-1 || xlow<xlowIn || xupp>xuppIn")); // # nocov
     if (rollToNearest) {   // value of roll ignored currently when nearest
       if ( (!lowmax || xlow>xlowIn) && (!uppmax || xupp<xuppIn) ) {
         if (  ( TYPEOF(ic)==REALSXP && REAL(ic)[ir]-REAL(xc)[XIND(xlow)] <= REAL(xc)[XIND(xupp)]-REAL(ic)[ir] ) // TODO remove macro here requires bigger rewrite
diff --git a/src/dogroups.c b/src/dogroups.c
index e07057b325..1cee6da79c 100644
--- a/src/dogroups.c
+++ b/src/dogroups.c
@@ -12,13 +12,19 @@ SEXP dogroups(SEXP dt, SEXP dtcols, SEXP groups, SEXP grpcols, SEXP jiscols, SEX
   clock_t tstart=0, tblock[10]={0}; int nblock[10]={0};
   const bool verbose = LOGICAL(verboseArg)[0]==1;
 
-  if (!isInteger(order)) error(_("Internal error: order not integer vector")); // # nocov
-  if (TYPEOF(starts) != INTSXP) error(_("Internal error: starts not integer")); // # nocov
-  if (TYPEOF(lens) != INTSXP) error(_("Internal error: lens not integer")); // # nocov
+  if (!isInteger(order))
+    error(_("Internal error: order not integer vector")); // # nocov
+  if (TYPEOF(starts) != INTSXP)
+    error(_("Internal error: starts not integer")); // # nocov
+  if (TYPEOF(lens) != INTSXP)
+    error(_("Internal error: lens not integer")); // # nocov
   // starts can now be NA (<0): if (INTEGER(starts)[0]<0 || INTEGER(lens)[0]<0) error(_("starts[1]<0 or lens[1]<0"));
-  if (!isNull(jiscols) && LENGTH(order) && !LOGICAL(on)[0]) error(_("Internal error: jiscols not NULL but o__ has length")); // # nocov
-  if (!isNull(xjiscols) && LENGTH(order) && !LOGICAL(on)[0]) error(_("Internal error: xjiscols not NULL but o__ has length")); // # nocov
-  if(!isEnvironment(env)) error(_("'env' should be an environment"));
+  if (!isNull(jiscols) && LENGTH(order) && !LOGICAL(on)[0])
+    error(_("Internal error: jiscols not NULL but o__ has length")); // # nocov
+  if (!isNull(xjiscols) && LENGTH(order) && !LOGICAL(on)[0])
+    error(_("Internal error: xjiscols not NULL but o__ has length")); // # nocov
+  if(!isEnvironment(env))
+    error(_("'env' should be an environment"));
   ngrp = length(starts);  // the number of groups  (nrow(groups) will be larger when by)
   ngrpcols = length(grpcols);
   nrowgroups = length(VECTOR_ELT(groups,0));
@@ -41,7 +47,8 @@ SEXP dogroups(SEXP dt, SEXP dtcols, SEXP groups, SEXP grpcols, SEXP jiscols, SEX
   }
   setAttrib(BY, R_NamesSymbol, bynames); // Fix for #42 - BY doesn't retain names anymore
   R_LockBinding(sym_BY, env);
-  if (isNull(jiscols) && (length(bynames)!=length(groups) || length(bynames)!=length(grpcols))) error(_("!length(bynames)[%d]==length(groups)[%d]==length(grpcols)[%d]"),length(bynames),length(groups),length(grpcols));
+  if (isNull(jiscols) && (length(bynames)!=length(groups) || length(bynames)!=length(grpcols)))
+    error(_("!length(bynames)[%d]==length(groups)[%d]==length(grpcols)[%d]"),length(bynames),length(groups),length(grpcols));
   // TO DO: check this check above.
 
   N =   PROTECT(findVar(install(".N"), env));   nprotect++; // PROTECT for rchk
@@ -60,14 +67,17 @@ SEXP dogroups(SEXP dt, SEXP dtcols, SEXP groups, SEXP grpcols, SEXP jiscols, SEX
   // fetch rownames of .SD.  rownames[1] is set to -thislen for each group, in case .SD is passed to
   // non data.table aware package that uses rownames
   for (s = ATTRIB(SD); s != R_NilValue && TAG(s)!=R_RowNamesSymbol; s = CDR(s));  // getAttrib0 basically but that's hidden in attrib.c
-  if (s==R_NilValue) error(_("row.names attribute of .SD not found"));
+  if (s==R_NilValue)
+    error(_("row.names attribute of .SD not found"));
   rownames = CAR(s);
-  if (!isInteger(rownames) || LENGTH(rownames)!=2 || INTEGER(rownames)[0]!=NA_INTEGER) error(_("row.names of .SD isn't integer length 2 with NA as first item; i.e., .set_row_names(). [%s %d %d]"),type2char(TYPEOF(rownames)),LENGTH(rownames),INTEGER(rownames)[0]);
+  if (!isInteger(rownames) || LENGTH(rownames)!=2 || INTEGER(rownames)[0]!=NA_INTEGER)
+    error(_("row.names of .SD isn't integer length 2 with NA as first item; i.e., .set_row_names(). [%s %d %d]"),type2char(TYPEOF(rownames)),LENGTH(rownames),INTEGER(rownames)[0]);
 
   // fetch names of .SD and prepare symbols. In case they are copied-on-write by user assigning to those variables
   // using <- in j (which is valid, useful and tested), they are repointed to the .SD cols for each group.
   SEXP names = PROTECT(getAttrib(SDall, R_NamesSymbol)); nprotect++;
-  if (length(names) != length(SDall)) error(_("length(names)!=length(SD)"));
+  if (length(names) != length(SDall))
+    error(_("length(names)!=length(SD)"));
   SEXP *nameSyms = (SEXP *)R_alloc(length(names), sizeof(SEXP));
   for(int i=0; i<length(SDall); ++i) {
     if (SIZEOF(VECTOR_ELT(SDall, i))==0)
@@ -81,7 +91,8 @@ SEXP dogroups(SEXP dt, SEXP dtcols, SEXP groups, SEXP grpcols, SEXP jiscols, SEX
   if (length(SDall)) origSDnrow = length(VECTOR_ELT(SDall, 0));
 
   SEXP xknames = PROTECT(getAttrib(xSD, R_NamesSymbol)); nprotect++;
-  if (length(xknames) != length(xSD)) error(_("length(xknames)!=length(xSD)"));
+  if (length(xknames) != length(xSD))
+    error(_("length(xknames)!=length(xSD)"));
   SEXP *xknameSyms = (SEXP *)R_alloc(length(xknames), sizeof(SEXP));
   for(int i=0; i<length(xSD); ++i) {
     if (SIZEOF(VECTOR_ELT(xSD, i))==0)
@@ -89,8 +100,10 @@ SEXP dogroups(SEXP dt, SEXP dtcols, SEXP groups, SEXP grpcols, SEXP jiscols, SEX
     xknameSyms[i] = install(CHAR(STRING_ELT(xknames, i)));
   }
 
-  if (length(iSD)!=length(jiscols)) error(_("length(iSD)[%d] != length(jiscols)[%d]"),length(iSD),length(jiscols));
-  if (length(xSD)!=length(xjiscols)) error(_("length(xSD)[%d] != length(xjiscols)[%d]"),length(xSD),length(xjiscols));
+  if (length(iSD)!=length(jiscols))
+    error(_("length(iSD)[%d] != length(jiscols)[%d]"),length(iSD),length(jiscols));
+  if (length(xSD)!=length(xjiscols))
+    error(_("length(xSD)[%d] != length(xjiscols)[%d]"),length(xSD),length(xjiscols));
 
   SEXP listwrap = PROTECT(allocVector(VECSXP, 1)); nprotect++;
   Rboolean jexpIsSymbolOtherThanSD = (isSymbol(jexp) && strcmp(CHAR(PRINTNAME(jexp)),".SD")!=0);  // test 559
@@ -227,7 +240,8 @@ SEXP dogroups(SEXP dt, SEXP dtcols, SEXP groups, SEXP grpcols, SEXP jiscols, SEX
         RHS = VECTOR_ELT(jval,j%LENGTH(jval));
         if (isNull(target)) {
           // first time adding to new column
-          if (TRUELENGTH(dt) < colj+1) error(_("Internal error: Trying to add new column by reference but tl is full; setalloccol should have run first at R level before getting to this point in dogroups")); // # nocov
+          if (TRUELENGTH(dt) < colj+1)
+            error(_("Internal error: Trying to add new column by reference but tl is full; setalloccol should have run first at R level before getting to this point in dogroups")); // # nocov
           target = PROTECT(allocNAVectorLike(RHS, n));
           // Even if we could know reliably to switch from allocNAVectorLike to allocVector for slight speedup, user code could still
           // contain a switched halt, and in that case we'd want the groups not yet done to have NA rather than 0 or uninitialized.
@@ -249,7 +263,8 @@ SEXP dogroups(SEXP dt, SEXP dtcols, SEXP groups, SEXP grpcols, SEXP jiscols, SEX
     }
     maxn = 0;
     if (njval==0) njval = LENGTH(jval);   // for first group, then the rest (when non 0) must conform to the first >0 group
-    if (njval!=LENGTH(jval)) error(_("j doesn't evaluate to the same number of columns for each group"));  // this would be a problem even if we unlisted afterwards. This way the user finds out earlier though so he can fix and rerun sooner.
+    if (njval!=LENGTH(jval))
+      error(_("j doesn't evaluate to the same number of columns for each group"));  // this would be a problem even if we unlisted afterwards. This way the user finds out earlier though so he can fix and rerun sooner.
     for (int j=0; j<njval; ++j) {
       int k = length(VECTOR_ELT(jval,j));  // might be NULL, so length not LENGTH
       maxn = k>maxn ? k : maxn;
@@ -309,7 +324,8 @@ SEXP dogroups(SEXP dt, SEXP dtcols, SEXP groups, SEXP grpcols, SEXP jiscols, SEX
       } else {
         estn = ((double)ngrp/i)*1.1*(ansloc+maxn);
         if (verbose) Rprintf(_("dogroups: growing from %d to %d rows\n"), length(VECTOR_ELT(ans,0)), estn);
-        if (length(ans) != ngrpcols + njval) error(_("dogroups: length(ans)[%d]!=ngrpcols[%d]+njval[%d]"),length(ans),ngrpcols,njval);
+        if (length(ans) != ngrpcols + njval)
+          error(_("dogroups: length(ans)[%d]!=ngrpcols[%d]+njval[%d]"),length(ans),ngrpcols,njval);
         for (int j=0; j<length(ans); ++j) SET_VECTOR_ELT(ans, j, growVector(VECTOR_ELT(ans,j), estn));
       }
     }
@@ -361,7 +377,8 @@ SEXP dogroups(SEXP dt, SEXP dtcols, SEXP groups, SEXP grpcols, SEXP jiscols, SEX
   for (int j=0; j<length(SDall); ++j) SETLENGTH(VECTOR_ELT(SDall,j), origSDnrow);
   SETLENGTH(I, origIlen);
   if (verbose) {
-    if (nblock[0] && nblock[1]) error(_("Internal error: block 0 [%d] and block 1 [%d] have both run"), nblock[0], nblock[1]); // # nocov
+    if (nblock[0] && nblock[1])
+      error(_("Internal error: block 0 [%d] and block 1 [%d] have both run"), nblock[0], nblock[1]); // # nocov
     int w = nblock[1]>0;
     Rprintf(_("\n  %s took %.3fs for %d groups\n"), w ? "collecting discontiguous groups" : "memcpy contiguous groups",
                           1.0*tblock[w]/CLOCKS_PER_SEC, nblock[w]);
@@ -389,7 +406,8 @@ SEXP growVector(SEXP x, const R_len_t newlen)
   // * much shorter and faster
   SEXP newx;
   R_len_t len = length(x);
-  if (isNull(x)) error(_("growVector passed NULL"));
+  if (isNull(x))
+    error(_("growVector passed NULL"));
   PROTECT(newx = allocVector(TYPEOF(x), newlen));   // TO DO: R_realloc(?) here?
   if (newlen < len) len=newlen;   // i.e. shrink
   switch (TYPEOF(x)) {
diff --git a/src/fcast.c b/src/fcast.c
index b8d6fa4c2a..a4bd735fd0 100644
--- a/src/fcast.c
+++ b/src/fcast.c
@@ -75,7 +75,8 @@ SEXP fcast(SEXP lhs, SEXP val, SEXP nrowArg, SEXP ncolArg, SEXP idxArg, SEXP fil
         }
       }
       break;
-    default: error(_("Unsupported column type in fcast val: '%s'"), type2char(TYPEOF(thiscol))); // #nocov
+    default:
+      error(_("Unsupported column type in fcast val: '%s'"), type2char(TYPEOF(thiscol))); // #nocov
     }
     UNPROTECT(nprotect);
   }
diff --git a/src/fmelt.c b/src/fmelt.c
index 3d1effa8a9..7ae1c69dcc 100644
--- a/src/fmelt.c
+++ b/src/fmelt.c
@@ -15,8 +15,10 @@ SEXP seq_int(int n, int start) {
 
 // very specific "set_diff" for integers
 SEXP set_diff(SEXP x, int n) {
-  if (TYPEOF(x) != INTSXP) error(_("'x' must be an integer"));
-  if (n <= 0) error(_("'n' must be a positive integer"));
+  if (TYPEOF(x) != INTSXP)
+    error(_("'x' must be an integer"));
+  if (n <= 0)
+    error(_("'n' must be a positive integer"));
   SEXP table = PROTECT(seq_int(n, 1));       // TODO: using match to 1:n seems odd here, why use match at all
   SEXP xmatch = PROTECT(match(x, table, 0)); // Old comment:took a while to realise: matches vec against x - thanks to comment from Matt in assign.c!
   const int *ixmatch = INTEGER(xmatch);
@@ -38,7 +40,8 @@ SEXP which(SEXP x, Rboolean val) {
 
   int j=0, n = length(x);
   SEXP ans;
-  if (!isLogical(x)) error(_("Argument to 'which' must be logical"));
+  if (!isLogical(x))
+    error(_("Argument to 'which' must be logical"));
   const int *ix = LOGICAL(x);
   int *buf = (int *) R_alloc(n, sizeof(int));
   for (int i=0; i<n; ++i) {
@@ -67,8 +70,10 @@ SEXP concat(SEXP vec, SEXP idx) {
   SEXP s, t, v;
   int nidx=length(idx);
 
-  if (TYPEOF(vec) != STRSXP) error(_("concat: 'vec must be a character vector"));
-  if (!isInteger(idx) || length(idx) < 0) error(_("concat: 'idx' must be an integer vector of length >= 0"));
+  if (TYPEOF(vec) != STRSXP)
+    error(_("concat: 'vec must be a character vector"));
+  if (!isInteger(idx) || length(idx) < 0)
+    error(_("concat: 'idx' must be an integer vector of length >= 0"));
   const int *iidx = INTEGER(idx);
   for (int i=0; i<length(idx); ++i) {
     if (iidx[i] < 0 || iidx[i] > length(vec))
@@ -99,7 +104,8 @@ SEXP measurelist(SEXP measure, SEXP dtnames) {
       case STRSXP  : tmp = PROTECT(chmatch(VECTOR_ELT(measure, i), dtnames, 0)); protecti++; break;
       case REALSXP : tmp = PROTECT(coerceVector(VECTOR_ELT(measure, i), INTSXP)); protecti++; break;
       case INTSXP  : tmp = VECTOR_ELT(measure, i); break;
-      default : error(_("Unknown 'measure.vars' type %s at index %d of list"), type2char(TYPEOF(VECTOR_ELT(measure, i))), i+1);
+      default :
+        error(_("Unknown 'measure.vars' type %s at index %d of list"), type2char(TYPEOF(VECTOR_ELT(measure, i))), i+1);
     }
     SET_VECTOR_ELT(ans, i, tmp);
   }
@@ -151,7 +157,8 @@ SEXP checkVars(SEXP DT, SEXP id, SEXP measure, Rboolean verbose) {
       case STRSXP  : PROTECT(tmp = chmatch(id, dtnames, 0)); protecti++; break;
       case REALSXP : PROTECT(tmp = coerceVector(id, INTSXP)); protecti++; break;
       case INTSXP  : tmp = id; break;
-      default : error(_("Unknown 'id.vars' type %s, must be character or integer vector"), type2char(TYPEOF(id)));
+      default :
+        error(_("Unknown 'id.vars' type %s, must be character or integer vector"), type2char(TYPEOF(id)));
     }
     booltmp = PROTECT(duplicated(tmp, FALSE)); protecti++;
     for (i=0; i<length(tmp); i++) {
@@ -181,7 +188,8 @@ SEXP checkVars(SEXP DT, SEXP id, SEXP measure, Rboolean verbose) {
       case REALSXP : tmp2 = PROTECT(coerceVector(measure, INTSXP)); protecti++; break;
       case INTSXP  : tmp2 = measure; break;
       case VECSXP  : tmp2 = PROTECT(measurelist(measure, dtnames)); protecti++; break;
-      default : error(_("Unknown 'measure.vars' type %s, must be character or integer vector/list"), type2char(TYPEOF(measure)));
+      default :
+        error(_("Unknown 'measure.vars' type %s, must be character or integer vector/list"), type2char(TYPEOF(measure)));
     }
     tmp = tmp2;
     if (isNewList(measure)) {
@@ -216,7 +224,8 @@ SEXP checkVars(SEXP DT, SEXP id, SEXP measure, Rboolean verbose) {
       case STRSXP  : tmp = PROTECT(chmatch(id, dtnames, 0)); protecti++; break;
       case REALSXP : tmp = PROTECT(coerceVector(id, INTSXP)); protecti++; break;
       case INTSXP  : tmp = id; break;
-      default : error(_("Unknown 'id.vars' type %s, must be character or integer vector"), type2char(TYPEOF(id)));
+      default :
+        error(_("Unknown 'id.vars' type %s, must be character or integer vector"), type2char(TYPEOF(id)));
     }
     for (i=0; i<length(tmp); i++) {
       if (INTEGER(tmp)[i] <= 0 || INTEGER(tmp)[i] > ncol)
@@ -228,7 +237,8 @@ SEXP checkVars(SEXP DT, SEXP id, SEXP measure, Rboolean verbose) {
       case REALSXP : tmp2 = PROTECT(coerceVector(measure, INTSXP)); protecti++; break;
       case INTSXP  : tmp2 = measure; break;
       case VECSXP  : tmp2 = PROTECT(measurelist(measure, dtnames)); protecti++; break;
-      default : error(_("Unknown 'measure.vars' type %s, must be character or integer vector"), type2char(TYPEOF(measure)));
+      default :
+        error(_("Unknown 'measure.vars' type %s, must be character or integer vector"), type2char(TYPEOF(measure)));
     }
     tmp = tmp2;
     if (isNewList(measure)) {
@@ -273,7 +283,8 @@ static void preprocess(SEXP DT, SEXP id, SEXP measure, SEXP varnames, SEXP valna
   data->lvalues = length(data->valuecols);
   data->narm = narm;
   if (length(valnames) != data->lvalues) {
-    if (isNewList(measure)) error(_("When 'measure.vars' is a list, 'value.name' must be a character vector of length =1 or =length(measure.vars)."));
+    if (isNewList(measure))
+      error(_("When 'measure.vars' is a list, 'value.name' must be a character vector of length =1 or =length(measure.vars)."));
     else error(_("When 'measure.vars' is either not specified or a character/integer vector, 'value.name' must be a character vector of length =1."));
   }
   if (length(varnames) != 1)
@@ -326,10 +337,12 @@ static SEXP combineFactorLevels(SEXP factorLevels, SEXP target, int * factorType
   int maxlevels=0, nitem=length(factorLevels);
   for (int i=0; i<nitem; ++i) {
     SEXP this = VECTOR_ELT(factorLevels, i);
-    if (!isString(this)) error(_("Internal error: combineFactorLevels in fmelt.c expects all-character input"));  // # nocov
+    if (!isString(this))
+      error(_("Internal error: combineFactorLevels in fmelt.c expects all-character input"));  // # nocov
     maxlevels+=length(this);
   }
-  if (!isString(target)) error(_("Internal error: combineFactorLevels in fmelt.c expects a character target to factorize"));  // # nocov
+  if (!isString(target))
+    error(_("Internal error: combineFactorLevels in fmelt.c expects a character target to factorize"));  // # nocov
   int nrow = length(target);
   SEXP ans = PROTECT(allocVector(INTSXP, nrow));
   SEXP *levelsRaw = (SEXP *)R_alloc(maxlevels, sizeof(SEXP));  // allocate for worst-case all-unique levels
@@ -659,7 +672,8 @@ SEXP getidcols(SEXP DT, SEXP dtnames, Rboolean verbose, struct processData *data
       }
     }
       break;
-    default : error(_("Unknown column type '%s' for column '%s' in 'data'"), type2char(TYPEOF(thiscol)), CHAR(STRING_ELT(dtnames, INTEGER(data->idcols)[i]-1)));
+    default :
+      error(_("Unknown column type '%s' for column '%s' in 'data'"), type2char(TYPEOF(thiscol)), CHAR(STRING_ELT(dtnames, INTEGER(data->idcols)[i]-1)));
     }
   }
   UNPROTECT(1);
@@ -670,13 +684,20 @@ SEXP fmelt(SEXP DT, SEXP id, SEXP measure, SEXP varfactor, SEXP valfactor, SEXP
   SEXP dtnames, ansvals, ansvars, ansids, ansnames, ans;
   Rboolean narm=FALSE, verbose=FALSE;
 
-  if (!isNewList(DT)) error(_("Input is not of type VECSXP, expected a data.table, data.frame or list"));
-  if (!isLogical(valfactor)) error(_("Argument 'value.factor' should be logical TRUE/FALSE"));
-  if (!isLogical(varfactor)) error(_("Argument 'variable.factor' should be logical TRUE/FALSE"));
-  if (!isLogical(narmArg)) error(_("Argument 'na.rm' should be logical TRUE/FALSE."));
-  if (!isString(varnames)) error(_("Argument 'variable.name' must be a character vector"));
-  if (!isString(valnames)) error(_("Argument 'value.name' must be a character vector"));
-  if (!isLogical(verboseArg)) error(_("Argument 'verbose' should be logical TRUE/FALSE"));
+  if (!isNewList(DT))
+    error(_("Input is not of type VECSXP, expected a data.table, data.frame or list"));
+  if (!isLogical(valfactor))
+    error(_("Argument 'value.factor' should be logical TRUE/FALSE"));
+  if (!isLogical(varfactor))
+    error(_("Argument 'variable.factor' should be logical TRUE/FALSE"));
+  if (!isLogical(narmArg))
+    error(_("Argument 'na.rm' should be logical TRUE/FALSE."));
+  if (!isString(varnames))
+    error(_("Argument 'variable.name' must be a character vector"));
+  if (!isString(valnames))
+    error(_("Argument 'value.name' must be a character vector"));
+  if (!isLogical(verboseArg))
+    error(_("Argument 'verbose' should be logical TRUE/FALSE"));
   if (LOGICAL(verboseArg)[0] == TRUE) verbose = TRUE;
   int ncol = LENGTH(DT);
   if (!ncol) {
@@ -685,7 +706,8 @@ SEXP fmelt(SEXP DT, SEXP id, SEXP measure, SEXP varfactor, SEXP valfactor, SEXP
   }
   int protecti=0;
   dtnames = PROTECT(getAttrib(DT, R_NamesSymbol)); protecti++;
-  if (isNull(dtnames)) error(_("names(data) is NULL. Please report to data.table-help"));
+  if (isNull(dtnames))
+    error(_("names(data) is NULL. Please report to data.table-help"));
   if (LOGICAL(narmArg)[0] == TRUE) narm = TRUE;
   if (LOGICAL(verboseArg)[0] == TRUE) verbose = TRUE;
   struct processData data;
diff --git a/src/forder.c b/src/forder.c
index ea0be76d04..66ced36e50 100644
--- a/src/forder.c
+++ b/src/forder.c
@@ -374,8 +374,10 @@ static uint64_t dmask=0;
 SEXP setNumericRounding(SEXP droundArg)
 // init.c has initial call with default of 2
 {
-  if (!isInteger(droundArg) || LENGTH(droundArg)!=1) error(_("Must an integer or numeric vector length 1"));
-  if (INTEGER(droundArg)[0] < 0 || INTEGER(droundArg)[0] > 2) error(_("Must be 2, 1 or 0"));
+  if (!isInteger(droundArg) || LENGTH(droundArg)!=1)
+    error(_("Must an integer or numeric vector length 1"));
+  if (INTEGER(droundArg)[0] < 0 || INTEGER(droundArg)[0] > 2)
+    error(_("Must be 2, 1 or 0"));
   dround = INTEGER(droundArg)[0];
   dmask = dround ? 1 << (8*dround-1) : 0;
   return R_NilValue;
@@ -1307,11 +1309,14 @@ SEXP isOrderedSubset(SEXP x, SEXP nrowArg)
 // specialized for use in [.data.table only
 // Ignores 0s but heeds NAs and any out-of-range (which result in NA)
 {
-  if (!isNull(x) && !isInteger(x)) error(_("x must be either NULL or an integer vector"));
+  if (!isNull(x) && !isInteger(x))
+    error(_("x must be either NULL or an integer vector"));
   if (length(x)<=1) return(ScalarLogical(TRUE));  // a single NA when length(x)==1 is ordered (e.g. tests 128 & 130) otherwise anyNA => FALSE
-  if (!isInteger(nrowArg) || LENGTH(nrowArg)!=1) error(_("nrow must be integer vector length 1"));
+  if (!isInteger(nrowArg) || LENGTH(nrowArg)!=1)
+    error(_("nrow must be integer vector length 1"));
   const int nrow = INTEGER(nrowArg)[0];
-  if (nrow<0) error(_("nrow==%d but must be >=0"), nrow);
+  if (nrow<0)
+    error(_("nrow==%d but must be >=0"), nrow);
   const int *xd = INTEGER(x), xlen=LENGTH(x);
   for (int i=0, last=INT_MIN; i<xlen; ++i) {
     int elem = xd[i];
@@ -1328,7 +1333,8 @@ SEXP binary(SEXP x)
 {
   char buffer[69];
   int j;
-  if (!isReal(x)) error(_("x must be type 'double'"));
+  if (!isReal(x))
+    error(_("x must be type 'double'"));
   SEXP ans = PROTECT(allocVector(STRSXP, LENGTH(x)));
   uint64_t *xd = (uint64_t *)REAL(x);
   for (int i=0; i<LENGTH(x); i++) {
diff --git a/src/frank.c b/src/frank.c
index 565154c70d..e150be739f 100644
--- a/src/frank.c
+++ b/src/frank.c
@@ -6,8 +6,10 @@
 SEXP dt_na(SEXP x, SEXP cols) {
   int n=0, elem;
 
-  if (!isNewList(x)) error(_("Internal error. Argument 'x' to Cdt_na is type '%s' not 'list'"), type2char(TYPEOF(x))); // # nocov
-  if (!isInteger(cols)) error(_("Internal error. Argument 'cols' to Cdt_na is type '%s' not 'integer'"), type2char(TYPEOF(cols))); // # nocov
+  if (!isNewList(x))
+    error(_("Internal error. Argument 'x' to Cdt_na is type '%s' not 'list'"), type2char(TYPEOF(x))); // # nocov
+  if (!isInteger(cols))
+    error(_("Internal error. Argument 'cols' to Cdt_na is type '%s' not 'integer'"), type2char(TYPEOF(cols))); // # nocov
   for (int i=0; i<LENGTH(cols); ++i) {
     elem = INTEGER(cols)[i];
     if (elem<1 || elem>LENGTH(x))
@@ -136,7 +138,8 @@ SEXP frank(SEXP xorderArg, SEXP xstartArg, SEXP xlenArg, SEXP ties_method) {
     //       INTEGER(ans)[xorder[j]-1] = k++;
     //   }
     //   break;
-    default: error(_("Internal error: unknown ties value in frank: %d"), ties); // #nocov
+    default:
+      error(_("Internal error: unknown ties value in frank: %d"), ties); // #nocov
     }
   }
   UNPROTECT(1);
@@ -147,8 +150,10 @@ SEXP frank(SEXP xorderArg, SEXP xstartArg, SEXP xlenArg, SEXP ties_method) {
 SEXP anyNA(SEXP x, SEXP cols) {
   int i, j, n=0, elem;
 
-  if (!isNewList(x)) error(_("Internal error. Argument 'x' to CanyNA is type '%s' not 'list'"), type2char(TYPEOF(x))); // #nocov
-  if (!isInteger(cols)) error(_("Internal error. Argument 'cols' to CanyNA is type '%s' not 'integer'"), type2char(TYPEOF(cols))); // # nocov
+  if (!isNewList(x))
+    error(_("Internal error. Argument 'x' to CanyNA is type '%s' not 'list'"), type2char(TYPEOF(x))); // #nocov
+  if (!isInteger(cols))
+    error(_("Internal error. Argument 'cols' to CanyNA is type '%s' not 'integer'"), type2char(TYPEOF(cols))); // # nocov
   for (i=0; i<LENGTH(cols); i++) {
     elem = INTEGER(cols)[i];
     if (elem<1 || elem>LENGTH(x))
diff --git a/src/freadR.c b/src/freadR.c
index 283f069557..e4c2124a81 100644
--- a/src/freadR.c
+++ b/src/freadR.c
@@ -150,14 +150,16 @@ SEXP freadR(
   args.skipEmptyLines = LOGICAL(skipEmptyLinesArg)[0];
   args.fill = LOGICAL(fillArg)[0];
   args.showProgress = LOGICAL(showProgressArg)[0];
-  if (INTEGER(nThreadArg)[0]<1) error(_("nThread(%d)<1"), INTEGER(nThreadArg)[0]);
+  if (INTEGER(nThreadArg)[0]<1)
+    error(_("nThread(%d)<1"), INTEGER(nThreadArg)[0]);
   args.nth = (uint32_t)INTEGER(nThreadArg)[0];
   args.verbose = verbose;
   args.warningsAreErrors = warningsAreErrors;
   args.keepLeadingZeros = LOGICAL(keepLeadingZerosArgs)[0];
 
   // === extras used for callbacks ===
-  if (!isString(integer64Arg) || LENGTH(integer64Arg)!=1) error(_("'integer64' must be a single character string"));
+  if (!isString(integer64Arg) || LENGTH(integer64Arg)!=1)
+    error(_("'integer64' must be a single character string"));
   const char *tt = CHAR(STRING_ELT(integer64Arg,0));
   if (strcmp(tt, "integer64")==0) {
     readInt64As = CT_INT64;
diff --git a/src/fsort.c b/src/fsort.c
index d3c695eac3..590431f4ed 100644
--- a/src/fsort.c
+++ b/src/fsort.c
@@ -108,7 +108,8 @@ SEXP fsort(SEXP x, SEXP verboseArg) {
   if (!isLogical(verboseArg) || LENGTH(verboseArg)!=1 || LOGICAL(verboseArg)[0]==NA_LOGICAL)
     error(_("verbose must be TRUE or FALSE"));
   Rboolean verbose = LOGICAL(verboseArg)[0];
-  if (!isNumeric(x)) error(_("x must be a vector of type 'double' currently"));
+  if (!isNumeric(x))
+    error(_("x must be a vector of type 'double' currently"));
   // TODO: not only detect if already sorted, but if it is, just return x to save the duplicate
 
   SEXP ansVec = PROTECT(allocVector(REALSXP, xlength(x)));
@@ -154,7 +155,8 @@ SEXP fsort(SEXP x, SEXP verboseArg) {
     if (maxs[i]>max) max=maxs[i];
   }
   if (verbose) Rprintf(_("Range = [%g,%g]\n"), min, max);
-  if (min < 0.0) error(_("Cannot yet handle negatives."));
+  if (min < 0.0)
+    error(_("Cannot yet handle negatives."));
   // TODO: -0ULL should allow negatives
   //       avoid twiddle function call as expensive in recent tests (0.34 vs 2.7)
   //       possibly twiddle once to *ans, then untwiddle at the end in a fast parallel sweep
@@ -170,7 +172,8 @@ SEXP fsort(SEXP x, SEXP verboseArg) {
   if (verbose) Rprintf(_("maxBit=%d; MSBNbits=%d; shift=%d; MSBsize=%d\n"), maxBit, MSBNbits, shift, MSBsize);
 
   R_xlen_t *counts = calloc(nBatch*MSBsize, sizeof(R_xlen_t));
-  if (counts==NULL) error(_("Unable to allocate working memory"));
+  if (counts==NULL)
+    error(_("Unable to allocate working memory"));
   // provided MSBsize>=9, each batch is a multiple of at least one 4k page, so no page overlap
   // TODO: change all calloc, malloc and free to Calloc and Free to be robust to error() and catch ooms.
 
@@ -228,7 +231,8 @@ SEXP fsort(SEXP x, SEXP verboseArg) {
     // sort bins by size, largest first to minimise last-man-home
     R_xlen_t *msbCounts = counts + (nBatch-1)*MSBsize;
     // msbCounts currently contains the ending position of each MSB (the starting location of the next) even across empty
-    if (msbCounts[MSBsize-1] != xlength(x)) error(_("Internal error: counts[nBatch-1][MSBsize-1] != length(x)")); // # nocov
+    if (msbCounts[MSBsize-1] != xlength(x))
+      error(_("Internal error: counts[nBatch-1][MSBsize-1] != length(x)")); // # nocov
     R_xlen_t *msbFrom = malloc(MSBsize*sizeof(R_xlen_t));
     int *order = malloc(MSBsize*sizeof(int));
     R_xlen_t cumSum = 0;
diff --git a/src/fwriteR.c b/src/fwriteR.c
index 6c8a450d3c..911e3e22fa 100644
--- a/src/fwriteR.c
+++ b/src/fwriteR.c
@@ -38,7 +38,8 @@ int getMaxStringLen(const SEXP *col, const int64_t n) {
 
 int getMaxCategLen(SEXP col) {
   col = getAttrib(col, R_LevelsSymbol);
-  if (!isString(col)) error(_("Internal error: col passed to getMaxCategLen is missing levels"));
+  if (!isString(col))
+    error(_("Internal error: col passed to getMaxCategLen is missing levels"));
   return getMaxStringLen( STRING_PTR(col), LENGTH(col) );
 }
 
@@ -167,7 +168,8 @@ SEXP fwriteR(
   SEXP verbose_Arg
   )
 {
-  if (!isNewList(DF)) error(_("fwrite must be passed an object of type list; e.g. data.frame, data.table"));
+  if (!isNewList(DF))
+    error(_("fwrite must be passed an object of type list; e.g. data.frame, data.table"));
   fwriteMainArgs args;
   args.is_gzip = LOGICAL(is_gzip_Arg)[0];
   args.bom = LOGICAL(bom_Arg)[0];
diff --git a/src/gsumm.c b/src/gsumm.c
index ef63519a3c..f7f078d05c 100644
--- a/src/gsumm.c
+++ b/src/gsumm.c
@@ -40,11 +40,15 @@ static int nbit(int n)
 SEXP gforce(SEXP env, SEXP jsub, SEXP o, SEXP f, SEXP l, SEXP irowsArg) {
   double started = wallclock();
   const bool verbose = GetVerbose();
-  if (TYPEOF(env) != ENVSXP) error(_("env is not an environment"));
+  if (TYPEOF(env) != ENVSXP)
+    error(_("env is not an environment"));
   // The type of jsub is pretty flexbile in R, so leave checking to eval() below.
-  if (!isInteger(o)) error(_("%s is not an integer vector"), "o");
-  if (!isInteger(f)) error(_("%s is not an integer vector"), "f");
-  if (!isInteger(l)) error(_("%s is not an integer vector"), "l");
+  if (!isInteger(o))
+    error(_("%s is not an integer vector"), "o");
+  if (!isInteger(f))
+    error(_("%s is not an integer vector"), "f");
+  if (!isInteger(l))
+    error(_("%s is not an integer vector"), "l");
   if (isNull(irowsArg)) {
     irows = NULL;
     irowslen = -1;
@@ -55,7 +59,8 @@ SEXP gforce(SEXP env, SEXP jsub, SEXP o, SEXP f, SEXP l, SEXP irowsArg) {
   }
   else error(_("irowsArg is neither an integer vector nor NULL"));  // # nocov
   ngrp = LENGTH(l);
-  if (LENGTH(f) != ngrp) error(_("length(f)=%d != length(l)=%d"), LENGTH(f), ngrp);
+  if (LENGTH(f) != ngrp)
+    error(_("length(f)=%d != length(l)=%d"), LENGTH(f), ngrp);
   nrow=0;
   grpsize = INTEGER(l);
   maxgrpn = 0;
@@ -63,10 +68,12 @@ SEXP gforce(SEXP env, SEXP jsub, SEXP o, SEXP f, SEXP l, SEXP irowsArg) {
     nrow+=grpsize[i];
     if (grpsize[i]>maxgrpn) maxgrpn = grpsize[i];  // old comment to be checked: 'needed for #2046 and #2111 when maxgrpn attribute is not attached to empty o'
   }
-  if (LENGTH(o) && LENGTH(o)!=nrow) error(_("o has length %d but sum(l)=%d"), LENGTH(o), nrow);
+  if (LENGTH(o) && LENGTH(o)!=nrow)
+    error(_("o has length %d but sum(l)=%d"), LENGTH(o), nrow);
   {
     SEXP tt = getAttrib(o, install("maxgrpn"));
-    if (length(tt)==1 && INTEGER(tt)[0]!=maxgrpn) error(_("Internal error: o's maxgrpn attribute mismatches recalculated maxgrpn")); // # nocov
+    if (length(tt)==1 && INTEGER(tt)[0]!=maxgrpn)
+      error(_("Internal error: o's maxgrpn attribute mismatches recalculated maxgrpn")); // # nocov
   }
 
   int nb = nbit(ngrp-1);
@@ -113,7 +120,8 @@ SEXP gforce(SEXP env, SEXP jsub, SEXP o, SEXP f, SEXP l, SEXP irowsArg) {
     //Rprintf(_("When assigning grp[o] = g, highSize=%d  nb=%d  shift=%d  nBatch=%d\n"), highSize, nb, shift, nBatch);
     int *counts = calloc(nBatch*highSize, sizeof(int));  // TODO: cache-line align and make highSize a multiple of 64
     int *TMP   = malloc(nrow*2*sizeof(int));
-    if (!counts || !TMP ) error(_("Internal error: Failed to allocate counts or TMP when assigning g in gforce"));
+    if (!counts || !TMP )
+      error(_("Internal error: Failed to allocate counts or TMP when assigning g in gforce"));
     #pragma omp parallel for num_threads(getDTthreads())   // schedule(dynamic,1)
     for (int b=0; b<nBatch; b++) {
       const int howMany = b==nBatch-1 ? lastBatchSize : batchSize;
@@ -339,15 +347,18 @@ void *gather(SEXP x, bool *anyNA)
 
 SEXP gsum(SEXP x, SEXP narmArg, SEXP warnOverflowArg)
 {
-  if (!isLogical(narmArg) || LENGTH(narmArg)!=1 || LOGICAL(narmArg)[0]==NA_LOGICAL) error(_("na.rm must be TRUE or FALSE"));
+  if (!isLogical(narmArg) || LENGTH(narmArg)!=1 || LOGICAL(narmArg)[0]==NA_LOGICAL)
+    error(_("na.rm must be TRUE or FALSE"));
   const bool narm = LOGICAL(narmArg)[0];
   const bool warnOverflow = LOGICAL(warnOverflowArg)[0];
-  if (inherits(x, "factor")) error(_("sum is not meaningful for factors."));
+  if (inherits(x, "factor"))
+    error(_("sum is not meaningful for factors."));
   const int n = (irowslen == -1) ? length(x) : irowslen;
   double started = wallclock();
   const bool verbose=GetVerbose();
   if (verbose) Rprintf(_("This gsum took (narm=%s) ... "), narm?"TRUE":"FALSE");
-  if (nrow != n) error(_("nrow [%d] != length(x) [%d] in %s"), nrow, n, "gsum");
+  if (nrow != n)
+    error(_("nrow [%d] != length(x) [%d] in %s"), nrow, n, "gsum");
   bool anyNA=false;
   SEXP ans;
   switch(TYPEOF(x)) {
@@ -574,9 +585,12 @@ SEXP gmean(SEXP x, SEXP narm)
 {
   SEXP ans=R_NilValue;
   //clock_t start = clock();
-  if (!isLogical(narm) || LENGTH(narm)!=1 || LOGICAL(narm)[0]==NA_LOGICAL) error(_("na.rm must be TRUE or FALSE"));
-  if (!isVectorAtomic(x)) error(_("GForce mean can only be applied to columns, not .SD or similar. Likely you're looking for 'DT[,lapply(.SD,mean),by=,.SDcols=]'. See ?data.table."));
-  if (inherits(x, "factor")) error(_("mean is not meaningful for factors."));
+  if (!isLogical(narm) || LENGTH(narm)!=1 || LOGICAL(narm)[0]==NA_LOGICAL)
+    error(_("na.rm must be TRUE or FALSE"));
+  if (!isVectorAtomic(x))
+    error(_("GForce mean can only be applied to columns, not .SD or similar. Likely you're looking for 'DT[,lapply(.SD,mean),by=,.SDcols=]'. See ?data.table."));
+  if (inherits(x, "factor"))
+    error(_("mean is not meaningful for factors."));
   if (!LOGICAL(narm)[0]) {
     int protecti=0;
     ans = PROTECT(gsum(x, narm, /*#986, warnOverflow=*/ScalarLogical(FALSE))); protecti++;
@@ -603,13 +617,16 @@ SEXP gmean(SEXP x, SEXP narm)
   }
   // na.rm=TRUE.  Similar to gsum, but we need to count the non-NA as well for the divisor
   const int n = (irowslen == -1) ? length(x) : irowslen;
-  if (nrow != n) error(_("nrow [%d] != length(x) [%d] in %s"), nrow, n, "gsum");
+  if (nrow != n)
+    error(_("nrow [%d] != length(x) [%d] in %s"), nrow, n, "gsum");
 
   long double *s = calloc(ngrp, sizeof(long double)), *si=NULL;  // s = sum; si = sum imaginary just for complex
-  if (!s) error(_("Unable to allocate %d * %d bytes for sum in gmean na.rm=TRUE"), ngrp, sizeof(long double));
+  if (!s)
+    error(_("Unable to allocate %d * %d bytes for sum in gmean na.rm=TRUE"), ngrp, sizeof(long double));
 
   int *c = calloc(ngrp, sizeof(int));
-  if (!c) error(_("Unable to allocate %d * %d bytes for counts in gmean na.rm=TRUE"), ngrp, sizeof(int));
+  if (!c)
+    error(_("Unable to allocate %d * %d bytes for counts in gmean na.rm=TRUE"), ngrp, sizeof(int));
 
   switch(TYPEOF(x)) {
   case LGLSXP: case INTSXP: {
@@ -635,7 +652,8 @@ SEXP gmean(SEXP x, SEXP narm)
   case CPLXSXP: {
     const Rcomplex *xd = COMPLEX(x);
     si = calloc(ngrp, sizeof(long double));
-    if (!si) error(_("Unable to allocate %d * %d bytes for si in gmean na.rm=TRUE"), ngrp, sizeof(long double));
+    if (!si)
+      error(_("Unable to allocate %d * %d bytes for si in gmean na.rm=TRUE"), ngrp, sizeof(long double));
     for (int i=0; i<n; i++) {
       int thisgrp = grp[i];
       int ix = (irowslen == -1) ? i : irows[i]-1;
@@ -683,14 +701,18 @@ SEXP gmean(SEXP x, SEXP narm)
 // gmin
 SEXP gmin(SEXP x, SEXP narm)
 {
-  if (!isLogical(narm) || LENGTH(narm)!=1 || LOGICAL(narm)[0]==NA_LOGICAL) error(_("na.rm must be TRUE or FALSE"));
-  if (!isVectorAtomic(x)) error(_("GForce min can only be applied to columns, not .SD or similar. To find min of all items in a list such as .SD, either add the prefix base::min(.SD) or turn off GForce optimization using options(datatable.optimize=1). More likely, you may be looking for 'DT[,lapply(.SD,min),by=,.SDcols=]'"));
-  if (inherits(x, "factor") && !inherits(x, "ordered")) error(_("min is not meaningful for factors."));
+  if (!isLogical(narm) || LENGTH(narm)!=1 || LOGICAL(narm)[0]==NA_LOGICAL)
+    error(_("na.rm must be TRUE or FALSE"));
+  if (!isVectorAtomic(x))
+    error(_("GForce min can only be applied to columns, not .SD or similar. To find min of all items in a list such as .SD, either add the prefix base::min(.SD) or turn off GForce optimization using options(datatable.optimize=1). More likely, you may be looking for 'DT[,lapply(.SD,min),by=,.SDcols=]'"));
+  if (inherits(x, "factor") && !inherits(x, "ordered"))
+    error(_("min is not meaningful for factors."));
   R_len_t i, ix, thisgrp=0;
   int n = (irowslen == -1) ? length(x) : irowslen;
   //clock_t start = clock();
   SEXP ans;
-  if (nrow != n) error(_("nrow [%d] != length(x) [%d] in %s"), nrow, n, "gmin");
+  if (nrow != n)
+    error(_("nrow [%d] != length(x) [%d] in %s"), nrow, n, "gmin");
   int protecti=0;
   switch(TYPEOF(x)) {
   case LGLSXP: case INTSXP:
@@ -802,14 +824,18 @@ SEXP gmin(SEXP x, SEXP narm)
 // gmax
 SEXP gmax(SEXP x, SEXP narm)
 {
-  if (!isLogical(narm) || LENGTH(narm)!=1 || LOGICAL(narm)[0]==NA_LOGICAL) error(_("na.rm must be TRUE or FALSE"));
-  if (!isVectorAtomic(x)) error(_("GForce max can only be applied to columns, not .SD or similar. To find max of all items in a list such as .SD, either add the prefix base::max(.SD) or turn off GForce optimization using options(datatable.optimize=1). More likely, you may be looking for 'DT[,lapply(.SD,max),by=,.SDcols=]'"));
-  if (inherits(x, "factor") && !inherits(x, "ordered")) error(_("max is not meaningful for factors."));
+  if (!isLogical(narm) || LENGTH(narm)!=1 || LOGICAL(narm)[0]==NA_LOGICAL)
+    error(_("na.rm must be TRUE or FALSE"));
+  if (!isVectorAtomic(x))
+    error(_("GForce max can only be applied to columns, not .SD or similar. To find max of all items in a list such as .SD, either add the prefix base::max(.SD) or turn off GForce optimization using options(datatable.optimize=1). More likely, you may be looking for 'DT[,lapply(.SD,max),by=,.SDcols=]'"));
+  if (inherits(x, "factor") && !inherits(x, "ordered"))
+    error(_("max is not meaningful for factors."));
   R_len_t i, ix, thisgrp=0;
   int n = (irowslen == -1) ? length(x) : irowslen;
   //clock_t start = clock();
   SEXP ans;
-  if (nrow != n) error(_("nrow [%d] != length(x) [%d] in %s"), nrow, n, "gmax");
+  if (nrow != n)
+    error(_("nrow [%d] != length(x) [%d] in %s"), nrow, n, "gmax");
 
   // TODO rework gmax in the same way as gmin and remove this *update
   char *update = (char *)R_alloc(ngrp, sizeof(char));
@@ -947,12 +973,16 @@ SEXP gmax(SEXP x, SEXP narm)
 
 // gmedian, always returns numeric type (to avoid as.numeric() wrap..)
 SEXP gmedian(SEXP x, SEXP narmArg) {
-  if (!isLogical(narmArg) || LENGTH(narmArg)!=1 || LOGICAL(narmArg)[0]==NA_LOGICAL) error(_("na.rm must be TRUE or FALSE"));
-  if (!isVectorAtomic(x)) error(_("GForce median can only be applied to columns, not .SD or similar. To find median of all items in a list such as .SD, either add the prefix stats::median(.SD) or turn off GForce optimization using options(datatable.optimize=1). More likely, you may be looking for 'DT[,lapply(.SD,median),by=,.SDcols=]'"));
-  if (inherits(x, "factor")) error(_("median is not meaningful for factors."));
+  if (!isLogical(narmArg) || LENGTH(narmArg)!=1 || LOGICAL(narmArg)[0]==NA_LOGICAL)
+    error(_("na.rm must be TRUE or FALSE"));
+  if (!isVectorAtomic(x))
+    error(_("GForce median can only be applied to columns, not .SD or similar. To find median of all items in a list such as .SD, either add the prefix stats::median(.SD) or turn off GForce optimization using options(datatable.optimize=1). More likely, you may be looking for 'DT[,lapply(.SD,median),by=,.SDcols=]'"));
+  if (inherits(x, "factor"))
+    error(_("median is not meaningful for factors."));
   const bool isInt64 = INHERITS(x, char_integer64), narm = LOGICAL(narmArg)[0];
   int n = (irowslen == -1) ? length(x) : irowslen;
-  if (nrow != n) error(_("nrow [%d] != length(x) [%d] in %s"), nrow, n, "gmedian");
+  if (nrow != n)
+    error(_("nrow [%d] != length(x) [%d] in %s"), nrow, n, "gmedian");
   SEXP ans = PROTECT(allocVector(REALSXP, ngrp));
   double *ansd = REAL(ans);
   switch(TYPEOF(x)) {
@@ -1002,7 +1032,8 @@ SEXP glast(SEXP x) {
   R_len_t i,k;
   int n = (irowslen == -1) ? length(x) : irowslen;
   SEXP ans;
-  if (nrow != n) error(_("nrow [%d] != length(x) [%d] in %s"), nrow, n, "gtail");
+  if (nrow != n)
+    error(_("nrow [%d] != length(x) [%d] in %s"), nrow, n, "gtail");
   switch(TYPEOF(x)) {
   case LGLSXP: {
     const int *ix = LOGICAL(x);
@@ -1082,7 +1113,8 @@ SEXP gfirst(SEXP x) {
   R_len_t i,k;
   int n = (irowslen == -1) ? length(x) : irowslen;
   SEXP ans;
-  if (nrow != n) error(_("nrow [%d] != length(x) [%d] in %s"), nrow, n, "ghead");
+  if (nrow != n)
+    error(_("nrow [%d] != length(x) [%d] in %s"), nrow, n, "ghead");
   switch(TYPEOF(x)) {
   case LGLSXP: {
     int const *ix = LOGICAL(x);
@@ -1158,22 +1190,26 @@ SEXP gfirst(SEXP x) {
 }
 
 SEXP gtail(SEXP x, SEXP valArg) {
-  if (!isInteger(valArg) || LENGTH(valArg)!=1 || INTEGER(valArg)[0]!=1) error(_("Internal error, gtail is only implemented for n=1. This should have been caught before. please report to data.table issue tracker.")); // # nocov
+  if (!isInteger(valArg) || LENGTH(valArg)!=1 || INTEGER(valArg)[0]!=1)
+    error(_("Internal error, gtail is only implemented for n=1. This should have been caught before. please report to data.table issue tracker.")); // # nocov
   return (glast(x));
 }
 
 SEXP ghead(SEXP x, SEXP valArg) {
-  if (!isInteger(valArg) || LENGTH(valArg)!=1 || INTEGER(valArg)[0]!=1) error(_("Internal error, ghead is only implemented for n=1. This should have been caught before. please report to data.table issue tracker.")); // # nocov
+  if (!isInteger(valArg) || LENGTH(valArg)!=1 || INTEGER(valArg)[0]!=1)
+    error(_("Internal error, ghead is only implemented for n=1. This should have been caught before. please report to data.table issue tracker.")); // # nocov
   return (gfirst(x));
 }
 
 SEXP gnthvalue(SEXP x, SEXP valArg) {
 
-  if (!isInteger(valArg) || LENGTH(valArg)!=1 || INTEGER(valArg)[0]<=0) error(_("Internal error, `g[` (gnthvalue) is only implemented single value subsets with positive index, e.g., .SD[2]. This should have been caught before. please report to data.table issue tracker.")); // # nocov
+  if (!isInteger(valArg) || LENGTH(valArg)!=1 || INTEGER(valArg)[0]<=0)
+    error(_("Internal error, `g[` (gnthvalue) is only implemented single value subsets with positive index, e.g., .SD[2]. This should have been caught before. please report to data.table issue tracker.")); // # nocov
   R_len_t i,k, val=INTEGER(valArg)[0];
   int n = (irowslen == -1) ? length(x) : irowslen;
   SEXP ans;
-  if (nrow != n) error(_("nrow [%d] != length(x) [%d] in %s"), nrow, n, "ghead");
+  if (nrow != n)
+    error(_("nrow [%d] != length(x) [%d] in %s"), nrow, n, "ghead");
   switch(TYPEOF(x)) {
   case LGLSXP: {
     const int *ix = LOGICAL(x);
@@ -1258,12 +1294,16 @@ SEXP gnthvalue(SEXP x, SEXP valArg) {
 // implemented this similar to gmedian to balance well between speed and memory usage. There's one extra allocation on maximum groups and that's it.. and that helps speed things up extremely since we don't have to collect x's values for each group for each step (mean, residuals, mean again and then variance).
 SEXP gvarsd1(SEXP x, SEXP narm, Rboolean isSD)
 {
-  if (!isLogical(narm) || LENGTH(narm)!=1 || LOGICAL(narm)[0]==NA_LOGICAL) error(_("na.rm must be TRUE or FALSE"));
-  if (!isVectorAtomic(x)) error(_("GForce var/sd can only be applied to columns, not .SD or similar. For the full covariance matrix of all items in a list such as .SD, either add the prefix stats::var(.SD) (or stats::sd(.SD)) or turn off GForce optimization using options(datatable.optimize=1). Alternatively, if you only need the diagonal elements, 'DT[,lapply(.SD,var),by=,.SDcols=]' is the optimized way to do this."));
-  if (inherits(x, "factor")) error(_("var/sd is not meaningful for factors."));
+  if (!isLogical(narm) || LENGTH(narm)!=1 || LOGICAL(narm)[0]==NA_LOGICAL)
+    error(_("na.rm must be TRUE or FALSE"));
+  if (!isVectorAtomic(x))
+    error(_("GForce var/sd can only be applied to columns, not .SD or similar. For the full covariance matrix of all items in a list such as .SD, either add the prefix stats::var(.SD) (or stats::sd(.SD)) or turn off GForce optimization using options(datatable.optimize=1). Alternatively, if you only need the diagonal elements, 'DT[,lapply(.SD,var),by=,.SDcols=]' is the optimized way to do this."));
+  if (inherits(x, "factor"))
+    error(_("var/sd is not meaningful for factors."));
   long double m, s, v;
   R_len_t i, j, ix, thisgrpsize = 0, n = (irowslen == -1) ? length(x) : irowslen;
-  if (nrow != n) error(_("nrow [%d] != length(x) [%d] in %s"), nrow, n, "gvar");
+  if (nrow != n)
+    error(_("nrow [%d] != length(x) [%d] in %s"), nrow, n, "gvar");
   SEXP sub, ans = PROTECT(allocVector(REALSXP, ngrp));
   Rboolean ans_na;
   switch(TYPEOF(x)) {
@@ -1399,16 +1439,21 @@ SEXP gsd(SEXP x, SEXP narm) {
 
 SEXP gprod(SEXP x, SEXP narm)
 {
-  if (!isLogical(narm) || LENGTH(narm)!=1 || LOGICAL(narm)[0]==NA_LOGICAL) error(_("na.rm must be TRUE or FALSE"));
-  if (!isVectorAtomic(x)) error(_("GForce prod can only be applied to columns, not .SD or similar. To multiply all items in a list such as .SD, either add the prefix base::prod(.SD) or turn off GForce optimization using options(datatable.optimize=1). More likely, you may be looking for 'DT[,lapply(.SD,prod),by=,.SDcols=]'"));
-  if (inherits(x, "factor")) error(_("prod is not meaningful for factors."));
+  if (!isLogical(narm) || LENGTH(narm)!=1 || LOGICAL(narm)[0]==NA_LOGICAL)
+    error(_("na.rm must be TRUE or FALSE"));
+  if (!isVectorAtomic(x))
+    error(_("GForce prod can only be applied to columns, not .SD or similar. To multiply all items in a list such as .SD, either add the prefix base::prod(.SD) or turn off GForce optimization using options(datatable.optimize=1). More likely, you may be looking for 'DT[,lapply(.SD,prod),by=,.SDcols=]'"));
+  if (inherits(x, "factor"))
+    error(_("prod is not meaningful for factors."));
   int i, ix, thisgrp;
   int n = (irowslen == -1) ? length(x) : irowslen;
   //clock_t start = clock();
   SEXP ans;
-  if (nrow != n) error(_("nrow [%d] != length(x) [%d] in %s"), nrow, n, "gprod");
+  if (nrow != n)
+    error(_("nrow [%d] != length(x) [%d] in %s"), nrow, n, "gprod");
   long double *s = malloc(ngrp * sizeof(long double));
-  if (!s) error(_("Unable to allocate %d * %d bytes for gprod"), ngrp, sizeof(long double));
+  if (!s)
+    error(_("Unable to allocate %d * %d bytes for gprod"), ngrp, sizeof(long double));
   for (i=0; i<ngrp; i++) s[i] = 1.0;
   ans = PROTECT(allocVector(REALSXP, ngrp));
   switch(TYPEOF(x)) {
diff --git a/src/ijoin.c b/src/ijoin.c
index 59bfd8fed4..d267cf40a9 100644
--- a/src/ijoin.c
+++ b/src/ijoin.c
@@ -53,7 +53,8 @@ SEXP lookup(SEXP ux, SEXP xlen, SEXP indices, SEXP gaps, SEXP overlaps, SEXP mul
           if (count[i]) type_count[i] = 1;
       }
       break;
-    default: error(_("Internal error: unknown type in mult=%d in lookup: %d"), mult, type); // #nocov
+    default:
+      error(_("Internal error: unknown type in mult=%d in lookup: %d"), mult, type); // #nocov
     }
     break;
 
@@ -118,10 +119,12 @@ SEXP lookup(SEXP ux, SEXP xlen, SEXP indices, SEXP gaps, SEXP overlaps, SEXP mul
         }
       }
       break;
-    default: error(_("Internal error: unknown type in mult=%d in lookup: %d"), mult, type); // #nocov
+    default:
+      error(_("Internal error: unknown type in mult=%d in lookup: %d"), mult, type); // #nocov
     }
     break;
-  default: error(_("Internal error: unknown mult in lookup: %d"), mult); // #nocov
+  default:
+    error(_("Internal error: unknown mult in lookup: %d"), mult); // #nocov
   }
   pass1 = clock() - start;
   if (LOGICAL(verbose)[0])
@@ -157,7 +160,8 @@ SEXP lookup(SEXP ux, SEXP xlen, SEXP indices, SEXP gaps, SEXP overlaps, SEXP mul
       INTEGER(VECTOR_ELT(lookup, to[i]-1))[idx[to[i]-1]++] = i+1;
     }
     break;
-  default: error(_("Internal error: unknown type lookup should have been caught earlier: %d"), type); // #nocov
+  default:
+    error(_("Internal error: unknown type lookup should have been caught earlier: %d"), type); // #nocov
   }
   Free(idx);
   // generate type_lookup
@@ -209,10 +213,12 @@ SEXP lookup(SEXP ux, SEXP xlen, SEXP indices, SEXP gaps, SEXP overlaps, SEXP mul
         //         INTEGER(tt)[j] = INTEGER(vv)[j];
         // }
         break; // #nocov
-      default: error(_("Internal error: unknown type in mult=%d in lookup should have been caught earlier: %d"), mult, type); // #nocov
+      default:
+        error(_("Internal error: unknown type in mult=%d in lookup should have been caught earlier: %d"), mult, type); // #nocov
       }
      break;
-    default: error(_("Internal error: unknown mult in lookup: %d"), mult); // #nocov
+    default:
+      error(_("Internal error: unknown mult in lookup: %d"), mult); // #nocov
     }
   }
   pass3 = clock() - start;
@@ -320,7 +326,8 @@ SEXP overlaps(SEXP ux, SEXP imatches, SEXP multArg, SEXP typeArg, SEXP nomatchAr
           ++totlen;
       }
       break;
-    default: error(_("Internal error: unknown type in mult=ALL in overlaps: %d"), mult, type); // #nocov
+    default:
+      error(_("Internal error: unknown type in mult=ALL in overlaps: %d"), mult, type); // #nocov
     }
   } else totlen = rows;
   end1 = clock() - start;
@@ -461,7 +468,8 @@ SEXP overlaps(SEXP ux, SEXP imatches, SEXP multArg, SEXP typeArg, SEXP nomatchAr
          }
       }
       break;
-    default: error(_("Internal error: unknown type in mult=%d in overlaps: %d"), mult, type); // #nocov
+    default:
+      error(_("Internal error: unknown type in mult=%d in overlaps: %d"), mult, type); // #nocov
     }
     break;
 
@@ -568,7 +576,8 @@ SEXP overlaps(SEXP ux, SEXP imatches, SEXP multArg, SEXP typeArg, SEXP nomatchAr
         }
       }
       break;
-    default: error(_("Internal error: unknown type in mult=%d in overlaps: %d"), mult, type); // #nocov
+    default:
+      error(_("Internal error: unknown type in mult=%d in overlaps: %d"), mult, type); // #nocov
     }
     break;
 
@@ -717,10 +726,12 @@ SEXP overlaps(SEXP ux, SEXP imatches, SEXP multArg, SEXP typeArg, SEXP nomatchAr
          }
       }
       break;
-    default: error(_("Internal error: unknown type in mult=%d in overlaps: %d"), mult, type); // #nocov
+    default:
+      error(_("Internal error: unknown type in mult=%d in overlaps: %d"), mult, type); // #nocov
     }
     break;
-  default: error(_("Internal error: unknown mult in overlaps: %d"), mult); // #nocov
+  default:
+    error(_("Internal error: unknown mult in overlaps: %d"), mult); // #nocov
   }
   end2 = clock() - start;
   if (LOGICAL(verbose)[0])
diff --git a/src/init.c b/src/init.c
index aed2da3dbd..6b56bd27da 100644
--- a/src/init.c
+++ b/src/init.c
@@ -230,7 +230,8 @@ static void setSizes() {
   sizes[CPLXSXP] = sizeof(Rcomplex);  typeorder[CPLXSXP] = 4;
   sizes[STRSXP] =  sizeof(SEXP *);    typeorder[STRSXP] =  5;
   sizes[VECSXP] =  sizeof(SEXP *);    typeorder[VECSXP] =  6;   // list column
-  if (sizeof(char *)>8) error(_("Pointers are %d bytes, greater than 8. We have not tested on any architecture greater than 64bit yet."), sizeof(char *));
+  if (sizeof(char *)>8)
+    error(_("Pointers are %d bytes, greater than 8. We have not tested on any architecture greater than 64bit yet."), sizeof(char *));
   // One place we need the largest sizeof is the working memory malloc in reorder.c
 }
 
@@ -244,59 +245,88 @@ void attribute_visible R_init_datatable(DllInfo *info)
   R_useDynamicSymbols(info, FALSE);
   setSizes();
   const char *msg = "... failed. Please forward this message to maintainer('data.table').";
-  if ((int)NA_INTEGER != (int)INT_MIN) error(_("Checking NA_INTEGER [%d] == INT_MIN [%d] %s"), NA_INTEGER, INT_MIN, msg);
-  if ((int)NA_INTEGER != (int)NA_LOGICAL) error(_("Checking NA_INTEGER [%d] == NA_LOGICAL [%d] %s"), NA_INTEGER, NA_LOGICAL, msg);
-  if (sizeof(int) != 4) error(_("Checking sizeof(int) [%d] is 4 %s"), sizeof(int), msg);
-  if (sizeof(double) != 8) error(_("Checking sizeof(double) [%d] is 8 %s"), sizeof(double), msg);     // 8 on both 32bit and 64bit
+  if ((int)NA_INTEGER != (int)INT_MIN)
+    error(_("Checking NA_INTEGER [%d] == INT_MIN [%d] %s"), NA_INTEGER, INT_MIN, msg);
+  if ((int)NA_INTEGER != (int)NA_LOGICAL)
+    error(_("Checking NA_INTEGER [%d] == NA_LOGICAL [%d] %s"), NA_INTEGER, NA_LOGICAL, msg);
+  if (sizeof(int) != 4)
+    error(_("Checking sizeof(int) [%d] is 4 %s"), sizeof(int), msg);
+  if (sizeof(double) != 8)
+    error(_("Checking sizeof(double) [%d] is 8 %s"), sizeof(double), msg);     // 8 on both 32bit and 64bit
   // alignof not available in C99: if (alignof(double) != 8) error(_("Checking alignof(double) [%d] is 8 %s"), alignof(double), msg);  // 8 on both 32bit and 64bit
-  if (sizeof(long long) != 8) error(_("Checking sizeof(long long) [%d] is 8 %s"), sizeof(long long), msg);
-  if (sizeof(char *) != 4 && sizeof(char *) != 8) error(_("Checking sizeof(pointer) [%d] is 4 or 8 %s"), sizeof(char *), msg);
-  if (sizeof(SEXP) != sizeof(char *)) error(_("Checking sizeof(SEXP) [%d] == sizeof(pointer) [%d] %s"), sizeof(SEXP), sizeof(char *), msg);
-  if (sizeof(uint64_t) != 8) error(_("Checking sizeof(uint64_t) [%d] is 8 %s"), sizeof(uint64_t), msg);
-  if (sizeof(int64_t) != 8) error(_("Checking sizeof(int64_t) [%d] is 8 %s"), sizeof(int64_t), msg);
-  if (sizeof(signed char) != 1) error(_("Checking sizeof(signed char) [%d] is 1 %s"), sizeof(signed char), msg);
-  if (sizeof(int8_t) != 1) error(_("Checking sizeof(int8_t) [%d] is 1 %s"), sizeof(int8_t), msg);
-  if (sizeof(uint8_t) != 1) error(_("Checking sizeof(uint8_t) [%d] is 1 %s"), sizeof(uint8_t), msg);
-  if (sizeof(int16_t) != 2) error(_("Checking sizeof(int16_t) [%d] is 2 %s"), sizeof(int16_t), msg);
-  if (sizeof(uint16_t) != 2) error(_("Checking sizeof(uint16_t) [%d] is 2 %s"), sizeof(uint16_t), msg);
+  if (sizeof(long long) != 8)
+    error(_("Checking sizeof(long long) [%d] is 8 %s"), sizeof(long long), msg);
+  if (sizeof(char *) != 4 && sizeof(char *) != 8)
+    error(_("Checking sizeof(pointer) [%d] is 4 or 8 %s"), sizeof(char *), msg);
+  if (sizeof(SEXP) != sizeof(char *))
+    error(_("Checking sizeof(SEXP) [%d] == sizeof(pointer) [%d] %s"), sizeof(SEXP), sizeof(char *), msg);
+  if (sizeof(uint64_t) != 8)
+    error(_("Checking sizeof(uint64_t) [%d] is 8 %s"), sizeof(uint64_t), msg);
+  if (sizeof(int64_t) != 8)
+    error(_("Checking sizeof(int64_t) [%d] is 8 %s"), sizeof(int64_t), msg);
+  if (sizeof(signed char) != 1)
+    error(_("Checking sizeof(signed char) [%d] is 1 %s"), sizeof(signed char), msg);
+  if (sizeof(int8_t) != 1)
+    error(_("Checking sizeof(int8_t) [%d] is 1 %s"), sizeof(int8_t), msg);
+  if (sizeof(uint8_t) != 1)
+    error(_("Checking sizeof(uint8_t) [%d] is 1 %s"), sizeof(uint8_t), msg);
+  if (sizeof(int16_t) != 2)
+    error(_("Checking sizeof(int16_t) [%d] is 2 %s"), sizeof(int16_t), msg);
+  if (sizeof(uint16_t) != 2)
+    error(_("Checking sizeof(uint16_t) [%d] is 2 %s"), sizeof(uint16_t), msg);
 
   SEXP tmp = PROTECT(allocVector(INTSXP,2));
-  if (LENGTH(tmp)!=2) error(_("Checking LENGTH(allocVector(INTSXP,2)) [%d] is 2 %s"), LENGTH(tmp), msg);
-  if (TRUELENGTH(tmp)!=0) error(_("Checking TRUELENGTH(allocVector(INTSXP,2)) [%d] is 0 %s"), TRUELENGTH(tmp), msg);
+  if (LENGTH(tmp)!=2)
+    error(_("Checking LENGTH(allocVector(INTSXP,2)) [%d] is 2 %s"), LENGTH(tmp), msg);
+  if (TRUELENGTH(tmp)!=0)
+    error(_("Checking TRUELENGTH(allocVector(INTSXP,2)) [%d] is 0 %s"), TRUELENGTH(tmp), msg);
   UNPROTECT(1);
 
   // According to IEEE (http://en.wikipedia.org/wiki/IEEE_754-1985#Zero) we can rely on 0.0 being all 0 bits.
   // But check here anyway just to be sure, just in case this answer is right (http://stackoverflow.com/a/2952680/403310).
   int i = 314;
   memset(&i, 0, sizeof(int));
-  if (i != 0) error(_("Checking memset(&i,0,sizeof(int)); i == (int)0 %s"), msg);
+  if (i != 0)
+    error(_("Checking memset(&i,0,sizeof(int)); i == (int)0 %s"), msg);
   unsigned int ui = 314;
   memset(&ui, 0, sizeof(unsigned int));
-  if (ui != 0) error(_("Checking memset(&ui, 0, sizeof(unsigned int)); ui == (unsigned int)0 %s"), msg);
+  if (ui != 0)
+    error(_("Checking memset(&ui, 0, sizeof(unsigned int)); ui == (unsigned int)0 %s"), msg);
   double d = 3.14;
   memset(&d, 0, sizeof(double));
-  if (d != 0.0) error(_("Checking memset(&d, 0, sizeof(double)); d == (double)0.0 %s"), msg);
+  if (d != 0.0)
+    error(_("Checking memset(&d, 0, sizeof(double)); d == (double)0.0 %s"), msg);
   long double ld = 3.14;
   memset(&ld, 0, sizeof(long double));
-  if (ld != 0.0) error(_("Checking memset(&ld, 0, sizeof(long double)); ld == (long double)0.0 %s"), msg);
+  if (ld != 0.0)
+    error(_("Checking memset(&ld, 0, sizeof(long double)); ld == (long double)0.0 %s"), msg);
 
   // Check unsigned cast used in fread.c. This isn't overflow/underflow, just cast.
-  if ((uint_fast8_t)('0'-'/') != 1) error(_("The ascii character '/' is not just before '0'"));
-  if ((uint_fast8_t)('/'-'0') < 10) error(_("The C expression (uint_fast8_t)('/'-'0')<10 is true. Should be false."));
-  if ((uint_fast8_t)(':'-'9') != 1) error(_("The ascii character ':' is not just after '9'"));
-  if ((uint_fast8_t)('9'-':') < 10) error(_("The C expression (uint_fast8_t)('9'-':')<10 is true. Should be false."));
+  if ((uint_fast8_t)('0'-'/') != 1)
+    error(_("The ascii character '/' is not just before '0'"));
+  if ((uint_fast8_t)('/'-'0') < 10)
+    error(_("The C expression (uint_fast8_t)('/'-'0')<10 is true. Should be false."));
+  if ((uint_fast8_t)(':'-'9') != 1)
+    error(_("The ascii character ':' is not just after '9'"));
+  if ((uint_fast8_t)('9'-':') < 10)
+    error(_("The C expression (uint_fast8_t)('9'-':')<10 is true. Should be false."));
 
   // Variables rather than #define for NA_INT64 to ensure correct usage; i.e. not casted
   NA_INT64_LL = LLONG_MIN;
   NA_INT64_D = LLtoD(NA_INT64_LL);
-  if (NA_INT64_LL != DtoLL(NA_INT64_D)) error(_("Conversion of NA_INT64 via double failed %"PRId64"!=%"PRId64), (int64_t)NA_INT64_LL, (int64_t)DtoLL(NA_INT64_D));
+  if (NA_INT64_LL != DtoLL(NA_INT64_D))
+    error(_("Conversion of NA_INT64 via double failed %"PRId64"!=%"PRId64), (int64_t)NA_INT64_LL, (int64_t)DtoLL(NA_INT64_D));
   // LLONG_MIN when punned to double is the sign bit set and then all zeros in exponent and significand i.e. -0.0
   //   That's why we must never test for NA_INT64_D using == in double type. Must always DtoLL and compare long long types.
   //   Assigning NA_INT64_D to a REAL is ok however.
-  if (NA_INT64_D != 0.0)  error(_("NA_INT64_D (negative -0.0) is not == 0.0."));
-  if (NA_INT64_D != -0.0) error(_("NA_INT64_D (negative -0.0) is not ==-0.0."));
-  if (ISNAN(NA_INT64_D)) error(_("ISNAN(NA_INT64_D) is TRUE but should not be"));
-  if (isnan(NA_INT64_D)) error(_("isnan(NA_INT64_D) is TRUE but should not be"));
+  if (NA_INT64_D != 0.0)
+    error(_("NA_INT64_D (negative -0.0) is not == 0.0."));
+  if (NA_INT64_D != -0.0)
+    error(_("NA_INT64_D (negative -0.0) is not ==-0.0."));
+  if (ISNAN(NA_INT64_D))
+    error(_("ISNAN(NA_INT64_D) is TRUE but should not be"));
+  if (isnan(NA_INT64_D))
+    error(_("isnan(NA_INT64_D) is TRUE but should not be"));
 
   NA_CPLX.r = NA_REAL;  // NA_REAL is defined as R_NaReal which is not a strict constant and thus initializer {NA_REAL, NA_REAL} can't be used in .h
   NA_CPLX.i = NA_REAL;  // https://github.com/Rdatatable/data.table/pull/3689/files#r304117234
@@ -394,7 +424,8 @@ SEXP hasOpenMP() {
 extern int *_Last_updated;  // assign.c
 
 SEXP initLastUpdated(SEXP var) {
-  if (!isInteger(var) || LENGTH(var)!=1) error(_(".Last.value in namespace is not a length 1 integer"));
+  if (!isInteger(var) || LENGTH(var)!=1)
+    error(_(".Last.value in namespace is not a length 1 integer"));
   _Last_updated = INTEGER(var);
   return R_NilValue;
 }
diff --git a/src/nafill.c b/src/nafill.c
index eb4e5c0e20..12f6a743d8 100644
--- a/src/nafill.c
+++ b/src/nafill.c
@@ -187,7 +187,8 @@ SEXP nafillR(SEXP obj, SEXP type, SEXP fill, SEXP nan_is_na_arg, SEXP inplace, S
     case INTSXP : {
       nafillInteger(ix[i], inx[i], itype, ifill, &vans[i], verbose);
     } break;
-    default: error(_("Internal error: invalid type argument in nafillR function, should have been caught before. Please report to data.table issue tracker.")); // # nocov
+    default:
+      error(_("Internal error: invalid type argument in nafillR function, should have been caught before. Please report to data.table issue tracker.")); // # nocov
     }
   }
   if (verbose)
diff --git a/src/openmp-utils.c b/src/openmp-utils.c
index b901601843..6d1f7d4126 100644
--- a/src/openmp-utils.c
+++ b/src/openmp-utils.c
@@ -64,7 +64,8 @@ static const char *mygetenv(const char *name, const char *unset) {
 }
 
 SEXP getDTthreads_R(SEXP verbose) {
-  if (!isLogical(verbose) || LENGTH(verbose)!=1 || INTEGER(verbose)[0]==NA_LOGICAL) error(_("'verbose' must be TRUE or FALSE"));
+  if (!isLogical(verbose) || LENGTH(verbose)!=1 || INTEGER(verbose)[0]==NA_LOGICAL)
+    error(_("'verbose' must be TRUE or FALSE"));
   if (LOGICAL(verbose)[0]) {
     #ifndef _OPENMP
       Rprintf(_("This installation of data.table has not been compiled with OpenMP support.\n"));
@@ -102,9 +103,11 @@ SEXP setDTthreads(SEXP threads, SEXP restore_after_fork, SEXP percent) {
     // reflect that and a call to setDTthreads(threads=NULL) will update DTthreads.
   } else {
     int n=0, protecti=0;
-    if (length(threads)!=1) error(_("threads= must be either NULL (default) or a single number. It has length %d"), length(threads));
+    if (length(threads)!=1)
+      error(_("threads= must be either NULL (default) or a single number. It has length %d"), length(threads));
     if (isReal(threads)) { threads = PROTECT(coerceVector(threads, INTSXP)); protecti++; }
-    if (!isInteger(threads)) error(_("threads= must be either NULL (default) or type integer/numeric"));
+    if (!isInteger(threads))
+      error(_("threads= must be either NULL (default) or type integer/numeric"));
     if ((n=INTEGER(threads)[0]) < 0) {  // <0 catches NA too since NA is negative (INT_MIN)
       error(_("threads= must be either NULL or a single integer >= 0. See ?setDTthreads."));
     }
@@ -114,7 +117,8 @@ SEXP setDTthreads(SEXP threads, SEXP restore_after_fork, SEXP percent) {
       error(_("Internal error: percent= must be TRUE or FALSE at C level"));  // # nocov
     }
     if (LOGICAL(percent)[0]) {
-      if (n<2 || n>100) error(_("Internal error: threads==%d should be between 2 and 100 (percent=TRUE at C level)."), n);  // # nocov
+      if (n<2 || n>100)
+        error(_("Internal error: threads==%d should be between 2 and 100 (percent=TRUE at C level)."), n);  // # nocov
       n = num_procs*n/100;  // if 0 it will be reset to 1 in the imax() below
     } else {
       if (n==0 || n>num_procs) n = num_procs; // setDTthreads(0) == setDTthread(percent=100); i.e. use all logical CPUs (the default in 1.12.0 and before, from 1.12.2 it's 50%)
diff --git a/src/rbindlist.c b/src/rbindlist.c
index f39b63f0a7..08093a7c6c 100644
--- a/src/rbindlist.c
+++ b/src/rbindlist.c
@@ -9,7 +9,8 @@ SEXP rbindlist(SEXP l, SEXP usenamesArg, SEXP fillArg, SEXP idcolArg)
   if (!isLogical(usenamesArg) || LENGTH(usenamesArg)!=1)
     error(_("use.names= should be TRUE, FALSE, or not used (\"check\" by default)"));  // R levels converts "check" to NA
   if (!length(l)) return(l);
-  if (TYPEOF(l) != VECSXP) error(_("Input to rbindlist must be a list. This list can contain data.tables, data.frames or plain lists."));
+  if (TYPEOF(l) != VECSXP)
+    error(_("Input to rbindlist must be a list. This list can contain data.tables, data.frames or plain lists."));
   Rboolean usenames = LOGICAL(usenamesArg)[0];
   const bool fill = LOGICAL(fillArg)[0];
   if (fill && usenames!=TRUE) {
@@ -17,7 +18,8 @@ SEXP rbindlist(SEXP l, SEXP usenamesArg, SEXP fillArg, SEXP idcolArg)
     usenames=TRUE;
   }
   const bool idcol = !isNull(idcolArg);
-  if (idcol && (!isString(idcolArg) || LENGTH(idcolArg)!=1)) error(_("Internal error: rbindlist.c idcol is not a single string"));  // # nocov
+  if (idcol && (!isString(idcolArg) || LENGTH(idcolArg)!=1))
+    error(_("Internal error: rbindlist.c idcol is not a single string"));  // # nocov
   int ncol=0, first=0;
   int64_t nrow=0, upperBoundUniqueNames=1;
   bool anyNames=false;
@@ -28,7 +30,8 @@ SEXP rbindlist(SEXP l, SEXP usenamesArg, SEXP fillArg, SEXP idcolArg)
     eachMax[i] = 0;
     SEXP li = VECTOR_ELT(l, i);
     if (isNull(li)) continue;
-    if (TYPEOF(li) != VECSXP) error(_("Item %d of input is not a data.frame, data.table or list"), i+1);
+    if (TYPEOF(li) != VECSXP)
+      error(_("Item %d of input is not a data.frame, data.table or list"), i+1);
     const int thisncol = length(li);
     if (!thisncol) continue;
     // delete as now more flexible ... if (fill && isNull(getAttrib(li, R_NamesSymbol))) error(_("When fill=TRUE every item of the input must have column names. Item %d does not."), i+1);
@@ -36,17 +39,20 @@ SEXP rbindlist(SEXP l, SEXP usenamesArg, SEXP fillArg, SEXP idcolArg)
       if (thisncol>ncol) ncol=thisncol;  // this section initializes ncol with max ncol. ncol may be increased when usenames is accounted for further down
     } else {
       if (ncol==0) { ncol=thisncol; first=i; }
-      else if (thisncol!=ncol) error(_("Item %d has %d columns, inconsistent with item %d which has %d columns. To fill missing columns use fill=TRUE."), i+1, thisncol, first+1, ncol);
+      else if (thisncol!=ncol)
+        error(_("Item %d has %d columns, inconsistent with item %d which has %d columns. To fill missing columns use fill=TRUE."), i+1, thisncol, first+1, ncol);
     }
     int nNames = length(getAttrib(li, R_NamesSymbol));
-    if (nNames>0 && nNames!=thisncol) error(_("Item %d has %d columns but %d column names. Invalid object."), i+1, thisncol, nNames);
+    if (nNames>0 && nNames!=thisncol)
+      error(_("Item %d has %d columns but %d column names. Invalid object."), i+1, thisncol, nNames);
     if (nNames>0) anyNames=true;
     upperBoundUniqueNames += nNames;
     int maxLen=0, whichMax=0;
     for (int j=0; j<thisncol; ++j) { int tt=length(VECTOR_ELT(li,j)); if (tt>maxLen) { maxLen=tt; whichMax=j; } }
     for (int j=0; j<thisncol; ++j) {
       int tt = length(VECTOR_ELT(li, j));
-      if (tt>1 && tt!=maxLen) error(_("Column %d of item %d is length %d inconsistent with column %d which is length %d. Only length-1 columns are recycled."), j+1, i+1, tt, whichMax+1, maxLen);
+      if (tt>1 && tt!=maxLen)
+        error(_("Column %d of item %d is length %d inconsistent with column %d which is length %d. Only length-1 columns are recycled."), j+1, i+1, tt, whichMax+1, maxLen);
       if (tt==0 && maxLen>0 && numZero++==0) { firstZeroCol = j; firstZeroItem=i; }
     }
     eachMax[i] = maxLen;
@@ -59,8 +65,10 @@ SEXP rbindlist(SEXP l, SEXP usenamesArg, SEXP fillArg, SEXP idcolArg)
             firstZeroCol+1, ch, firstZeroItem+1, numZero-1, numZero==2?"":"s");
   }
   if (nrow==0 && ncol==0) return(R_NilValue);
-  if (nrow>INT32_MAX) error(_("Total rows in the list is %"PRId64" which is larger than the maximum number of rows, currently %d"), (int64_t)nrow, INT32_MAX);
-  if (usenames==TRUE && !anyNames) error(_("use.names=TRUE but no item of input list has any names"));
+  if (nrow>INT32_MAX)
+    error(_("Total rows in the list is %"PRId64" which is larger than the maximum number of rows, currently %d"), (int64_t)nrow, INT32_MAX);
+  if (usenames==TRUE && !anyNames)
+    error(_("use.names=TRUE but no item of input list has any names"));
 
   int *colMap=NULL; // maps each column in final result to the column of each list item
   if (usenames==TRUE || usenames==NA_LOGICAL) {
@@ -68,7 +76,8 @@ SEXP rbindlist(SEXP l, SEXP usenamesArg, SEXP fillArg, SEXP idcolArg)
     // when use.names==NA we also proceed here as if use.names was TRUE to save new code and then check afterwards the map is 1:ncol for every item
     // first find number of unique column names present; i.e. length(unique(unlist(lapply(l,names))))
     SEXP *uniq = (SEXP *)malloc(upperBoundUniqueNames * sizeof(SEXP));  // upperBoundUniqueNames was initialized with 1 to ensure this is defined (otherwise 0 when no item has names)
-    if (!uniq) error(_("Failed to allocate upper bound of %"PRId64" unique column names [sum(lapply(l,ncol))]"), (int64_t)upperBoundUniqueNames);
+    if (!uniq)
+      error(_("Failed to allocate upper bound of %"PRId64" unique column names [sum(lapply(l,ncol))]"), (int64_t)upperBoundUniqueNames);
     savetl_init();
     int nuniq=0;
     for (int i=0; i<LENGTH(l); i++) {
@@ -188,7 +197,8 @@ SEXP rbindlist(SEXP l, SEXP usenamesArg, SEXP fillArg, SEXP idcolArg)
     // for (int i=0; i<LENGTH(l); ++i) { for (int j=0; j<ncol; ++j) Rprintf(_("%2d "),colMap[i*ncol + j]);  Rprintf(_("\n")); }
   }
 
-  if (fill && usenames==NA_LOGICAL) error(_("Internal error: usenames==NA but fill=TRUE. usenames should have been set to TRUE earlier with warning."));
+  if (fill && usenames==NA_LOGICAL)
+    error(_("Internal error: usenames==NA but fill=TRUE. usenames should have been set to TRUE earlier with warning."));
   if (!fill && (usenames==TRUE || usenames==NA_LOGICAL)) {
     // Ensure no missings in both cases, and (when usenames==NA) all columns in same order too
     // We proceeded earlier as if fill was true, so varying ncol items will have missings here
@@ -203,19 +213,22 @@ SEXP rbindlist(SEXP l, SEXP usenamesArg, SEXP fillArg, SEXP idcolArg)
         if (w==-1) {
           int missi = i;
           while (colMap[i*ncol + j]==-1 && i<LENGTH(l)) i++;
-          if (i==LENGTH(l)) error(_("Internal error: could not find the first column name not present in earlier item"));
+          if (i==LENGTH(l))
+            error(_("Internal error: could not find the first column name not present in earlier item"));
           SEXP s = getAttrib(VECTOR_ELT(l, i), R_NamesSymbol);
           int w2 = colMap[i*ncol + j];
           const char *str = isString(s) ? CHAR(STRING_ELT(s,w2)) : "";
           snprintf(buff, 1000, _("Column %d ['%s'] of item %d is missing in item %d. Use fill=TRUE to fill with NA (NULL for list columns), or use.names=FALSE to ignore column names.%s"),
                         w2+1, str, i+1, missi+1, extra );
-          if (usenames==TRUE) error(buff);
+          if (usenames==TRUE)
+            error(buff);
           i = LENGTH(l); // break from outer i loop
           break;         // break from inner j loop
         }
         if (w!=j && usenames==NA_LOGICAL) {
           SEXP s = getAttrib(VECTOR_ELT(l, i), R_NamesSymbol);
-          if (!isString(s) || i==0) error(_("Internal error: usenames==NA but an out-of-order name has been found in an item with no names or the first item. [%d]"), i);
+          if (!isString(s) || i==0)
+            error(_("Internal error: usenames==NA but an out-of-order name has been found in an item with no names or the first item. [%d]"), i);
           snprintf(buff, 1000, _("Column %d ['%s'] of item %d appears in position %d in item %d. Set use.names=TRUE to match by column name, or use.names=FALSE to ignore column names.%s"),
                                w+1, CHAR(STRING_ELT(s,w)), i+1, j+1, i, extra);
           i = LENGTH(l);
@@ -231,7 +244,8 @@ SEXP rbindlist(SEXP l, SEXP usenamesArg, SEXP fillArg, SEXP idcolArg)
         const char *o = isNull(opt) ? "message" : CHAR(STRING_ELT(opt,0));
         if      (strcmp(o,"message")==0) { eval(PROTECT(lang2(install("message"),PROTECT(ScalarString(mkChar(buff))))), R_GlobalEnv); UNPROTECT(2); }
         else if (strcmp(o,"warning")==0) warning(buff);
-        else if (strcmp(o,"error")==0)   error(buff);
+        else if (strcmp(o,"error")==0)
+          error(buff);
         else if (strcmp(o,"none")!=0)    warning(_("options()$datatable.rbindlist.check=='%s' which is not 'message'|'warning'|'error'|'none'. See news item 5 in v1.12.2."), o);
       }
     }
@@ -295,7 +309,8 @@ SEXP rbindlist(SEXP l, SEXP usenamesArg, SEXP fillArg, SEXP idcolArg)
       // Use >= for #546 -- TYPEORDER=0 for both LGLSXP and EXPRSXP (but also NULL)
       if (TYPEORDER(thisType)>=TYPEORDER(maxType) && !isNull(thisCol)) maxType=thisType;
       if (isFactor(thisCol)) {
-        if (isNull(getAttrib(thisCol,R_LevelsSymbol))) error(_("Column %d of item %d has type 'factor' but has no levels; i.e. malformed."), w+1, i+1);
+        if (isNull(getAttrib(thisCol,R_LevelsSymbol)))
+          error(_("Column %d of item %d has type 'factor' but has no levels; i.e. malformed."), w+1, i+1);
         factor = true;
         if (isOrdered(thisCol)) {
           orderedFactor = true;
@@ -359,7 +374,10 @@ SEXP rbindlist(SEXP l, SEXP usenamesArg, SEXP fillArg, SEXP idcolArg)
         const SEXP *sd = STRING_PTR(longestLevels);
         nLevel = allocLevel = longestLen;
         levelsRaw = (SEXP *)malloc(nLevel * sizeof(SEXP));
-        if (!levelsRaw) { savetl_end(); error(_("Failed to allocate working memory for %d ordered factor levels of result column %d"), nLevel, idcol+j+1); }
+        if (!levelsRaw) {
+          savetl_end();
+          error(_("Failed to allocate working memory for %d ordered factor levels of result column %d"), nLevel, idcol+j+1);
+        }
         for (int k=0; k<longestLen; ++k) {
           SEXP s = sd[k];
           if (TRUELENGTH(s)>0) savetl(s);
diff --git a/src/reorder.c b/src/reorder.c
index da3784e94d..d9d0766ea1 100644
--- a/src/reorder.c
+++ b/src/reorder.c
@@ -25,13 +25,16 @@ SEXP reorder(SEXP x, SEXP order)
   } else {
     if (SIZEOF(x)!=4 && SIZEOF(x)!=8 && SIZEOF(x)!=16)
       error(_("reorder accepts vectors but this non-VECSXP is type '%s' which isn't yet supported (SIZEOF=%d)"), type2char(TYPEOF(x)), SIZEOF(x));
-    if (ALTREP(x)) error(_("Internal error in reorder.c: cannot reorder an ALTREP vector. Please see NEWS item 2 in v1.11.4 and report this as a bug.")); // # nocov
+    if (ALTREP(x))
+      error(_("Internal error in reorder.c: cannot reorder an ALTREP vector. Please see NEWS item 2 in v1.11.4 and report this as a bug.")); // # nocov
     maxSize = SIZEOF(x);
     nrow = length(x);
     ncol = 1;
   }
-  if (!isInteger(order)) error(_("order must be an integer vector"));
-  if (length(order) != nrow) error(_("nrow(x)[%d]!=length(order)[%d]"),nrow,length(order));
+  if (!isInteger(order))
+    error(_("order must be an integer vector"));
+  if (length(order) != nrow)
+    error(_("nrow(x)[%d]!=length(order)[%d]"),nrow,length(order));
   int nprotect = 0;
   if (ALTREP(order)) { order=PROTECT(copyAsPlain(order)); nprotect++; }  // TODO: if it's an ALTREP sequence some optimizations are possible rather than expand
 
@@ -102,7 +105,8 @@ SEXP setcolorder(SEXP x, SEXP o)
 {
   SEXP names = getAttrib(x, R_NamesSymbol);
   const int ncol=LENGTH(x);
-  if (isNull(names)) error(_("dt passed to setcolorder has no names"));
+  if (isNull(names))
+    error(_("dt passed to setcolorder has no names"));
   if (ncol != LENGTH(names))
     error(_("Internal error: dt passed to setcolorder has %d columns but %d names"), ncol, LENGTH(names));  // # nocov
   SEXP tt = PROTECT(allocVector(VECSXP, 2));
diff --git a/src/shift.c b/src/shift.c
index 643283d7c0..5ba7722ff9 100644
--- a/src/shift.c
+++ b/src/shift.c
@@ -25,12 +25,17 @@ SEXP shift(SEXP obj, SEXP k, SEXP fill, SEXP type) {
   if (!strcmp(CHAR(STRING_ELT(type, 0)), "lag")) stype = LAG;
   else if (!strcmp(CHAR(STRING_ELT(type, 0)), "lead")) stype = LEAD;
   else if (!strcmp(CHAR(STRING_ELT(type, 0)), "shift")) stype = LAG; // when we get rid of nested if branches we can use SHIFT, for now it maps to LAG
-  else error(_("Internal error: invalid type for shift(), should have been caught before. please report to data.table issue tracker")); // # nocov
+  else
+    error(_("Internal error: invalid type for shift(), should have been caught before. please report to data.table issue tracker")); // # nocov
 
   int nx = length(x), nk = length(k);
-  if (!isInteger(k)) error(_("Internal error: k must be integer")); // # nocov
+  if (!isInteger(k))
+    error(_("Internal error: k must be integer")); // # nocov
   const int *kd = INTEGER(k);
-  for (int i=0; i<nk; i++) if (kd[i]==NA_INTEGER) error(_("Item %d of n is NA"), i+1);  // NA crashed (#3354); n is called k at C level
+  for (int i=0; i<nk; i++) {
+    if (kd[i]==NA_INTEGER)
+      error(_("Item %d of n is NA"), i+1);  // NA crashed (#3354); n is called k at C level
+  }
 
   ans = PROTECT(allocVector(VECSXP, nk * nx)); protecti++;
   for (int i=0; i<nx; i++) {
diff --git a/src/subset.c b/src/subset.c
index d9fea2800c..d43a742df3 100644
--- a/src/subset.c
+++ b/src/subset.c
@@ -4,7 +4,8 @@ void subsetVectorRaw(SEXP ans, SEXP source, SEXP idx, const bool anyNA)
 // Used here by subsetDT() and by dogroups.c
 {
   const int n = length(idx);
-  if (length(ans)!=n) error(_("Internal error: subsetVectorRaw length(ans)==%d n=%d"), length(ans), n);
+  if (length(ans)!=n)
+    error(_("Internal error: subsetVectorRaw length(ans)==%d n=%d"), length(ans), n);
 
   const int *restrict idxp = INTEGER(idx);
   // anyNA refers to NA _in idx_; if there's NA in the data (source) that's just regular data to be copied
@@ -89,7 +90,8 @@ static const char *check_idx(SEXP idx, int max, bool *anyNA_out, bool *orderedSu
 // error if any negatives, zeros or >max since they should have been dealt with by convertNegAndZeroIdx() called ealier at R level.
 // single cache efficient sweep with prefetch, so very low priority to go parallel
 {
-  if (!isInteger(idx)) error(_("Internal error. 'idx' is type '%s' not 'integer'"), type2char(TYPEOF(idx))); // # nocov
+  if (!isInteger(idx))
+    error(_("Internal error. 'idx' is type '%s' not 'integer'"), type2char(TYPEOF(idx))); // # nocov
   bool anyLess=false, anyNA=false;
   int last = INT32_MIN;
   int *idxp = INTEGER(idx), n=LENGTH(idx);
@@ -113,11 +115,15 @@ SEXP convertNegAndZeroIdx(SEXP idx, SEXP maxArg, SEXP allowOverMax)
   // + a little more efficient than negativeSubscript in src/main/subscript.c (it's private to R so we can't call it anyway)
   // allowOverMaxArg is false when := (test 1024), otherwise true for selecting
 
-  if (!isInteger(idx)) error(_("Internal error. 'idx' is type '%s' not 'integer'"), type2char(TYPEOF(idx))); // # nocov
-  if (!isInteger(maxArg) || length(maxArg)!=1) error(_("Internal error. 'maxArg' is type '%s' and length %d, should be an integer singleton"), type2char(TYPEOF(maxArg)), length(maxArg)); // # nocov
-  if (!isLogical(allowOverMax) || LENGTH(allowOverMax)!=1 || LOGICAL(allowOverMax)[0]==NA_LOGICAL) error(_("Internal error: allowOverMax must be TRUE/FALSE"));  // # nocov
+  if (!isInteger(idx))
+    error(_("Internal error. 'idx' is type '%s' not 'integer'"), type2char(TYPEOF(idx))); // # nocov
+  if (!isInteger(maxArg) || length(maxArg)!=1)
+    error(_("Internal error. 'maxArg' is type '%s' and length %d, should be an integer singleton"), type2char(TYPEOF(maxArg)), length(maxArg)); // # nocov
+  if (!isLogical(allowOverMax) || LENGTH(allowOverMax)!=1 || LOGICAL(allowOverMax)[0]==NA_LOGICAL)
+    error(_("Internal error: allowOverMax must be TRUE/FALSE"));  // # nocov
   int max = INTEGER(maxArg)[0], n=LENGTH(idx);
-  if (max<0) error(_("Internal error. max is %d, must be >= 0."), max); // # nocov    includes NA which will print as INT_MIN
+  if (max<0)
+    error(_("Internal error. max is %d, must be >= 0."), max); // # nocov    includes NA which will print as INT_MIN
   int *idxp = INTEGER(idx);
 
   bool stop = false;
@@ -215,7 +221,8 @@ SEXP convertNegAndZeroIdx(SEXP idx, SEXP maxArg, SEXP allowOverMax)
 
 static void checkCol(SEXP col, int colNum, int nrow, SEXP x)
 {
-  if (isNull(col)) error(_("Column %d is NULL; malformed data.table."), colNum);
+  if (isNull(col))
+    error(_("Column %d is NULL; malformed data.table."), colNum);
   if (isNewList(col) && INHERITS(col, char_dataframe)) {
     SEXP names = getAttrib(x, R_NamesSymbol);
     error(_("Column %d ['%s'] is a data.frame or data.table; malformed data.table."),
@@ -239,7 +246,8 @@ static void checkCol(SEXP col, int colNum, int nrow, SEXP x)
 
 SEXP subsetDT(SEXP x, SEXP rows, SEXP cols) { // API change needs update NEWS.md and man/cdt.Rd
   int nprotect=0;
-  if (!isNewList(x)) error(_("Internal error. Argument 'x' to CsubsetDT is type '%s' not 'list'"), type2char(TYPEOF(rows))); // # nocov
+  if (!isNewList(x))
+    error(_("Internal error. Argument 'x' to CsubsetDT is type '%s' not 'list'"), type2char(TYPEOF(rows))); // # nocov
   if (!length(x)) return(x);  // return empty list
 
   const int nrow = length(VECTOR_ELT(x,0));
@@ -249,13 +257,16 @@ SEXP subsetDT(SEXP x, SEXP rows, SEXP cols) { // API change needs update NEWS.md
     SEXP max = PROTECT(ScalarInteger(nrow)); nprotect++;
     rows = PROTECT(convertNegAndZeroIdx(rows, max, ScalarLogical(TRUE))); nprotect++;
     const char *err = check_idx(rows, nrow, &anyNA, &orderedSubset);
-    if (err!=NULL) error(err);
+    if (err!=NULL)
+      error(err);
   }
 
-  if (!isInteger(cols)) error(_("Internal error. Argument 'cols' to Csubset is type '%s' not 'integer'"), type2char(TYPEOF(cols))); // # nocov
+  if (!isInteger(cols))
+    error(_("Internal error. Argument 'cols' to Csubset is type '%s' not 'integer'"), type2char(TYPEOF(cols))); // # nocov
   for (int i=0; i<LENGTH(cols); i++) {
     int this = INTEGER(cols)[i];
-    if (this<1 || this>LENGTH(x)) error(_("Item %d of 'cols' is %d which is outside 1-based range [1,ncol(x)=%d]"), i+1, this, LENGTH(x));
+    if (this<1 || this>LENGTH(x))
+      error(_("Item %d of 'cols' is %d which is outside 1-based range [1,ncol(x)=%d]"), i+1, this, LENGTH(x));
   }
 
   int overAlloc = checkOverAlloc(GetOption(install("datatable.alloccol"), R_NilValue));
diff --git a/src/uniqlist.c b/src/uniqlist.c
index 447b3ea057..8f51bd61e2 100644
--- a/src/uniqlist.c
+++ b/src/uniqlist.c
@@ -11,12 +11,16 @@ SEXP uniqlist(SEXP l, SEXP order)
   // (maximum length the number of rows) and the length returned in anslen.
   // No NA in order which is guaranteed since internal-only. Used at R level internally (Cuniqlist) but is not and should not be exported.
   // DONE: ans is now grown
-  if (!isNewList(l)) error(_("Internal error: uniqlist has not been passed a list of columns")); // # nocov
+  if (!isNewList(l))
+    error(_("Internal error: uniqlist has not been passed a list of columns")); // # nocov
   R_len_t ncol = length(l);
   R_len_t nrow = length(VECTOR_ELT(l,0));
-  if (!isInteger(order)) error(_("Internal error: uniqlist has been passed a non-integer order")); // # nocov
-  if (LENGTH(order)<1) error(_("Internal error: uniqlist has been passed a length-0 order")); // # nocov
-  if (LENGTH(order)>1 && LENGTH(order)!=nrow) error(_("Internal error: uniqlist has been passed length(order)==%d but nrow==%d"), LENGTH(order), nrow); // # nocov
+  if (!isInteger(order))
+    error(_("Internal error: uniqlist has been passed a non-integer order")); // # nocov
+  if (LENGTH(order)<1)
+    error(_("Internal error: uniqlist has been passed a length-0 order")); // # nocov
+  if (LENGTH(order)>1 && LENGTH(order)!=nrow)
+    error(_("Internal error: uniqlist has been passed length(order)==%d but nrow==%d"), LENGTH(order), nrow); // # nocov
   bool via_order = INTEGER(order)[0] != -1;  // has an ordering vector been passed in that we have to hop via? Don't use MISSING() here as it appears unstable on Windows
 
   unsigned long long *ulv; // for numeric check speed-up
@@ -145,8 +149,10 @@ SEXP uniqlist(SEXP l, SEXP order)
 
 SEXP uniqlengths(SEXP x, SEXP n) {
   // seems very similar to rbindlist.c:uniq_lengths. TODO: centralize into common function
-  if (TYPEOF(x) != INTSXP) error(_("Input argument 'x' to 'uniqlengths' must be an integer vector"));
-  if (TYPEOF(n) != INTSXP || length(n) != 1) error(_("Input argument 'n' to 'uniqlengths' must be an integer vector of length 1"));
+  if (TYPEOF(x) != INTSXP)
+    error(_("Input argument 'x' to 'uniqlengths' must be an integer vector"));
+  if (TYPEOF(n) != INTSXP || length(n) != 1)
+    error(_("Input argument 'n' to 'uniqlengths' must be an integer vector of length 1"));
   R_len_t len = length(x);
   SEXP ans = PROTECT(allocVector(INTSXP, len));
   for (R_len_t i=1; i<len; i++) {
@@ -164,14 +170,17 @@ SEXP rleid(SEXP l, SEXP cols) {
   R_xlen_t nrow = xlength(VECTOR_ELT(l, 0));
   R_len_t ncol = length(l), lencols = length(cols);
   if (!nrow || !ncol) return(allocVector(INTSXP, 0));
-  if (!isInteger(cols) || lencols==0) error(_("cols must be an integer vector with length >= 1"));
+  if (!isInteger(cols) || lencols==0)
+    error(_("cols must be an integer vector with length >= 1"));
   int *icols = INTEGER(cols);
   for (int i=0; i<lencols; i++) {
     int elem = icols[i];
-    if (elem<1 || elem>ncol) error(_("Item %d of cols is %d which is outside range of l [1,length(l)=%d]"), i+1, elem, ncol);
+    if (elem<1 || elem>ncol)
+      error(_("Item %d of cols is %d which is outside range of l [1,length(l)=%d]"), i+1, elem, ncol);
   }
   for (int i=1; i<ncol; i++) {
-    if (xlength(VECTOR_ELT(l,i)) != nrow) error(_("All elements to input list must be of same length. Element [%d] has length %"PRIu64" != length of first element = %"PRIu64"."), i+1, (uint64_t)xlength(VECTOR_ELT(l,i)), (uint64_t)nrow);
+    if (xlength(VECTOR_ELT(l,i)) != nrow)
+      error(_("All elements to input list must be of same length. Element [%d] has length %"PRIu64" != length of first element = %"PRIu64"."), i+1, (uint64_t)xlength(VECTOR_ELT(l,i)), (uint64_t)nrow);
   }
   SEXP ans = PROTECT(allocVector(INTSXP, nrow));
   int *ians = INTEGER(ans);
@@ -252,16 +261,19 @@ SEXP rleid(SEXP l, SEXP cols) {
 SEXP nestedid(SEXP l, SEXP cols, SEXP order, SEXP grps, SEXP resetvals, SEXP multArg) {
   Rboolean byorder = (length(order)>0);
   SEXP v, ans;
-  if (!isNewList(l) || length(l) < 1) error(_("Internal error: nestedid was not passed a list length 1 or more")); // # nocov
+  if (!isNewList(l) || length(l) < 1)
+    error(_("Internal error: nestedid was not passed a list length 1 or more")); // # nocov
   R_len_t nrows = length(VECTOR_ELT(l,0)), ncols = length(cols);
   if (nrows==0) return(allocVector(INTSXP, 0));
   R_len_t thisi, previ, ansgrpsize=1000, nansgrp=0;
   R_len_t *ansgrp = Calloc(ansgrpsize, R_len_t), starts, grplen; // #3401 fix. Needs to be Calloc due to Realloc below .. else segfaults.
   R_len_t ngrps = length(grps);
   bool *i64 = (bool *)R_alloc(ncols, sizeof(bool));
-  if (ngrps==0) error(_("Internal error: nrows[%d]>0 but ngrps==0"), nrows); // # nocov
+  if (ngrps==0)
+    error(_("Internal error: nrows[%d]>0 but ngrps==0"), nrows); // # nocov
   R_len_t resetctr=0, rlen = length(resetvals) ? INTEGER(resetvals)[0] : 0;
-  if (!isInteger(cols) || ncols == 0) error(_("cols must be an integer vector of positive length"));
+  if (!isInteger(cols) || ncols == 0)
+    error(_("cols must be an integer vector of positive length"));
   // mult arg
   enum {ALL, FIRST, LAST} mult = ALL;
   if (!strcmp(CHAR(STRING_ELT(multArg, 0)), "all")) mult = ALL;
@@ -346,8 +358,10 @@ SEXP nestedid(SEXP l, SEXP cols, SEXP order, SEXP grps, SEXP resetvals, SEXP mul
 
 SEXP uniqueNlogical(SEXP x, SEXP narmArg) {
   // single pass; short-circuit and return as soon as all 3 values are found
-  if (!isLogical(x)) error(_("x is not a logical vector"));
-  if (!isLogical(narmArg) || length(narmArg)!=1 || INTEGER(narmArg)[0]==NA_INTEGER) error(_("na.rm must be TRUE or FALSE"));
+  if (!isLogical(x))
+    error(_("x is not a logical vector"));
+  if (!isLogical(narmArg) || length(narmArg)!=1 || INTEGER(narmArg)[0]==NA_INTEGER)
+    error(_("na.rm must be TRUE or FALSE"));
   bool narm = LOGICAL(narmArg)[0]==1;
   const R_xlen_t n = xlength(x);
   if (n==0)
diff --git a/src/utils.c b/src/utils.c
index 87348beb7c..4a07bdcec2 100644
--- a/src/utils.c
+++ b/src/utils.c
@@ -64,7 +64,7 @@ bool allNA(SEXP x, bool errorForBadType) {
     return true;
   case CPLXSXP: {
     const Rcomplex *xd = COMPLEX(x);
-    for (int i=0; i<n; ++i) if (!ISNAN_COMPLEX(xd[i])) { 
+    for (int i=0; i<n; ++i) if (!ISNAN_COMPLEX(xd[i])) {
       return false;
     }
     return true;
@@ -142,7 +142,8 @@ SEXP colnamesInt(SEXP x, SEXP cols, SEXP check_dups) {
 }
 
 void coerceFill(SEXP fill, double *dfill, int32_t *ifill, int64_t *i64fill) {
-  if (xlength(fill) != 1) error(_("%s: fill argument must be length 1"), __func__);
+  if (xlength(fill) != 1)
+    error(_("%s: fill argument must be length 1"), __func__);
   if (isInteger(fill)) {
     if (INTEGER(fill)[0]==NA_INTEGER) {
       ifill[0] = NA_INTEGER; dfill[0] = NA_REAL; i64fill[0] = NA_INTEGER64;
diff --git a/src/vecseq.c b/src/vecseq.c
index 9466c615b9..fccf0a225a 100644
--- a/src/vecseq.c
+++ b/src/vecseq.c
@@ -10,9 +10,12 @@ SEXP vecseq(SEXP x, SEXP len, SEXP clamp)
   // Specially for use by [.data.table after binary search. Now so specialized that for general use
   // bit::vecseq is recommended (Jens has coded it in C now).
 
-  if (!isInteger(x)) error(_("x must be an integer vector"));
-  if (!isInteger(len)) error(_("len must be an integer vector"));
-  if (LENGTH(x) != LENGTH(len)) error(_("x and len must be the same length"));
+  if (!isInteger(x))
+    error(_("x must be an integer vector"));
+  if (!isInteger(len))
+    error(_("len must be an integer vector"));
+  if (LENGTH(x) != LENGTH(len))
+    error(_("x and len must be the same length"));
   const int *ix = INTEGER(x);
   const int *ilen = INTEGER(len), nlen=LENGTH(len);
   int reslen = 0;
@@ -22,10 +25,13 @@ SEXP vecseq(SEXP x, SEXP len, SEXP clamp)
     reslen += ilen[i];
   }
   if (!isNull(clamp)) {
-    if (!isNumeric(clamp) || LENGTH(clamp)!=1) error(_("clamp must be a double vector length 1"));
+    if (!isNumeric(clamp) || LENGTH(clamp)!=1)
+      error(_("clamp must be a double vector length 1"));
     double limit = REAL(clamp)[0];
-    if (limit<0) error(_("clamp must be positive"));
-    if (reslen>limit) error(_("Join results in %d rows; more than %d = nrow(x)+nrow(i). Check for duplicate key values in i each of which join to the same group in x over and over again. If that's ok, try by=.EACHI to run j for each group to avoid the large allocation. If you are sure you wish to proceed, rerun with allow.cartesian=TRUE. Otherwise, please search for this error message in the FAQ, Wiki, Stack Overflow and data.table issue tracker for advice."), reslen, (int)limit);
+    if (limit<0)
+      error(_("clamp must be positive"));
+    if (reslen>limit)
+      error(_("Join results in %d rows; more than %d = nrow(x)+nrow(i). Check for duplicate key values in i each of which join to the same group in x over and over again. If that's ok, try by=.EACHI to run j for each group to avoid the large allocation. If you are sure you wish to proceed, rerun with allow.cartesian=TRUE. Otherwise, please search for this error message in the FAQ, Wiki, Stack Overflow and data.table issue tracker for advice."), reslen, (int)limit);
   }
   SEXP ans = PROTECT(allocVector(INTSXP, reslen));
   int *ians = INTEGER(ans);
diff --git a/src/wrappers.c b/src/wrappers.c
index a23b169685..a470ff9e46 100644
--- a/src/wrappers.c
+++ b/src/wrappers.c
@@ -8,7 +8,8 @@
 
 SEXP setattrib(SEXP x, SEXP name, SEXP value)
 {
-  if (!isString(name) || LENGTH(name)!=1) error(_("Attribute name must be a character vector of length 1"));
+  if (!isString(name) || LENGTH(name)!=1)
+    error(_("Attribute name must be a character vector of length 1"));
   if (!isNewList(x) &&
       strcmp(CHAR(STRING_ELT(name,0)),"class")==0 &&
       isString(value) && LENGTH(value)>0 &&
@@ -63,10 +64,13 @@ SEXP setlistelt(SEXP l, SEXP i, SEXP value)
 {
   R_len_t i2;
   // Internal use only. So that := can update elements of a list of data.table, #2204. Just needed to overallocate/grow the VECSXP.
-  if (!isNewList(l)) error(_("First argument to setlistelt must be a list()"));
-  if (!isInteger(i) || LENGTH(i)!=1) error(_("Second argument to setlistelt must a length 1 integer vector"));
+  if (!isNewList(l))
+    error(_("First argument to setlistelt must be a list()"));
+  if (!isInteger(i) || LENGTH(i)!=1)
+    error(_("Second argument to setlistelt must a length 1 integer vector"));
   i2 = INTEGER(i)[0];
-  if (LENGTH(l) < i2 || i2<1) error(_("i (%d) is outside the range of items [1,%d]"),i2,LENGTH(l));
+  if (LENGTH(l) < i2 || i2<1)
+    error(_("i (%d) is outside the range of items [1,%d]"),i2,LENGTH(l));
   SET_VECTOR_ELT(l, i2-1, value);
   return(R_NilValue);
 }
@@ -88,7 +92,8 @@ SEXP expandAltRep(SEXP x)
   // At R level (for example [.data.table) we use and benefit from altrep vectors very much. It's just as columns that we expand them.
   // See extensive discussion in issue #2866
 
-  if (TYPEOF(x) != VECSXP) error(_("x isn't a VECSXP"));
+  if (TYPEOF(x) != VECSXP)
+    error(_("x isn't a VECSXP"));
   for (int i=0; i<LENGTH(x); i++) {
     SEXP col = VECTOR_ELT(x,i);
     if (ALTREP(col)) {

From 602b1943952729b5b5b87bfed4873433671f1223 Mon Sep 17 00:00:00 2001
From: Michael Chirico <michael.chirico@grabtaxi.com>
Date: Fri, 13 Mar 2020 14:34:14 +0800
Subject: [PATCH 02/23] include regex to CRAN_Release

---
 .dev/CRAN_Release.cmd | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/.dev/CRAN_Release.cmd b/.dev/CRAN_Release.cmd
index e629ee980b..b86e0bf158 100644
--- a/.dev/CRAN_Release.cmd
+++ b/.dev/CRAN_Release.cmd
@@ -153,6 +153,12 @@ grep -nE "(llu|lld|zd|zu)" src/*.[hc]
 grep -P "\t" ./R/*.R
 grep -P "\t" ./src/*.c
 
+# all error branches should be on a new line to be properly included in codecov; exceptions:
+#   (1) in a comment (pattern: after // or after \s*[*]
+#   (2) in '} else error(' pattern (if else is covered, so is the error)
+#   (3) in #define macros
+grep -Enr "\berror[(]" src --include=*.c | grep -Ev "^src/[a-zA-Z-]+[.]c:[0-9]+:\s*(?:error|(?:[}]\s*)?else error|#define|[*]|.*//.*error)"
+
 # No T or F symbols in tests.Rraw. 24 valid F (quoted, column name or in data) and 1 valid T at the time of writing
 grep -n "[^A-Za-z0-9]T[^A-Za-z0-9]" ./inst/tests/tests.Rraw
 grep -n "[^A-Za-z0-9]F[^A-Za-z0-9]" ./inst/tests/tests.Rraw

From b8db05d0092d9ee1e304127af403bb328af7c33b Mon Sep 17 00:00:00 2001
From: Michael Chirico <michael.chirico@grabtaxi.com>
Date: Fri, 13 Mar 2020 15:04:19 +0800
Subject: [PATCH 03/23] do warnings as well

---
 .dev/CRAN_Release.cmd | 4 +++-
 src/assign.c          | 9 ++++++---
 src/gsumm.c           | 3 ++-
 src/rbindlist.c       | 9 ++++++---
 4 files changed, 17 insertions(+), 8 deletions(-)

diff --git a/.dev/CRAN_Release.cmd b/.dev/CRAN_Release.cmd
index b86e0bf158..4ef92db8c1 100644
--- a/.dev/CRAN_Release.cmd
+++ b/.dev/CRAN_Release.cmd
@@ -157,7 +157,9 @@ grep -P "\t" ./src/*.c
 #   (1) in a comment (pattern: after // or after \s*[*]
 #   (2) in '} else error(' pattern (if else is covered, so is the error)
 #   (3) in #define macros
-grep -Enr "\berror[(]" src --include=*.c | grep -Ev "^src/[a-zA-Z-]+[.]c:[0-9]+:\s*(?:error|(?:[}]\s*)?else error|#define|[*]|.*//.*error)"
+for type in error warning; do
+  grep -Enr "\b$type[(]" src --include=*.c | grep -Ev "^src\/[a-zA-Z-]+[.]c:[0-9]+:\s*(?:(?:[}]?\s*else\s*)?$type|#define|[*]|.*\/\/.*$type)"
+done
 
 # No T or F symbols in tests.Rraw. 24 valid F (quoted, column name or in data) and 1 valid T at the time of writing
 grep -n "[^A-Za-z0-9]T[^A-Za-z0-9]" ./inst/tests/tests.Rraw
diff --git a/src/assign.c b/src/assign.c
index bb1d929e51..cacfa56d7a 100644
--- a/src/assign.c
+++ b/src/assign.c
@@ -226,7 +226,8 @@ SEXP alloccol(SEXP dt, R_len_t n, Rboolean verbose)
     error(_("Internal error, tl of class is marked but tl<0.")); // # nocov
   if (tl>0 && tl<l)
     error(_("Internal error, please report (including result of sessionInfo()) to data.table issue tracker: tl (%d) < l (%d) but tl of class is marked."), tl, l); // # nocov
-  if (tl>l+10000) warning(_("tl (%d) is greater than 10,000 items over-allocated (l = %d). If you didn't set the datatable.alloccol option to be very large, please report to data.table issue tracker including the result of sessionInfo()."),tl,l);
+  if (tl>l+10000)
+    warning(_("tl (%d) is greater than 10,000 items over-allocated (l = %d). If you didn't set the datatable.alloccol option to be very large, please report to data.table issue tracker including the result of sessionInfo()."),tl,l);
   if (n>tl) return(shallow(dt,R_NilValue,n)); // usual case (increasing alloc)
   if (n<tl && verbose) Rprintf(_("Attempt to reduce allocation from %d to %d ignored. Can only increase allocation via shallow copy. Please do not use DT[...]<- or DT$someCol<-. Use := inside DT[...] instead."),tl,n);
         // otherwise the finalizer can't clear up the Large Vector heap
@@ -470,7 +471,8 @@ SEXP assign(SEXP dt, SEXP rows, SEXP cols, SEXP newcolnames, SEXP values)
         error(_("This data.table has either been loaded from disk (e.g. using readRDS()/load()) or constructed manually (e.g. using structure()). Please run setDT() or setalloccol() on it first (to pre-allocate space for new columns) before assigning by reference to it."));   // #2996
       error(_("Internal error: oldtncol(%d) < oldncol(%d). Please report to data.table issue tracker, including result of sessionInfo()."), oldtncol, oldncol); // # nocov
     }
-    if (oldtncol>oldncol+10000L) warning(_("truelength (%d) is greater than 10,000 items over-allocated (length = %d). See ?truelength. If you didn't set the datatable.alloccol option very large, please report to data.table issue tracker including the result of sessionInfo()."),oldtncol, oldncol);
+    if (oldtncol>oldncol+10000L)
+      warning(_("truelength (%d) is greater than 10,000 items over-allocated (length = %d). See ?truelength. If you didn't set the datatable.alloccol option very large, please report to data.table issue tracker including the result of sessionInfo()."),oldtncol, oldncol);
     if (oldtncol < oldncol+LENGTH(newcolnames))
       error(_("Internal error: DT passed to assign has not been allocated enough column slots. l=%d, tl=%d, adding %d"), oldncol, oldtncol, LENGTH(newcolnames));  // # nocov
     if (!selfrefnamesok(dt,verbose))
@@ -527,7 +529,8 @@ SEXP assign(SEXP dt, SEXP rows, SEXP cols, SEXP newcolnames, SEXP values)
       targetcol = VECTOR_ELT(dt,coln);
     }
     const char *ret = memrecycle(targetcol, rows, 0, targetlen, thisvalue, 0, -1, coln+1, CHAR(STRING_ELT(names, coln)));
-    if (ret) warning(ret);
+    if (ret)
+      warning(ret);
   }
 
   *_Last_updated = numToDo;  // the updates have taken place with no error, so update .Last.updated now
diff --git a/src/gsumm.c b/src/gsumm.c
index f7f078d05c..8500b5061b 100644
--- a/src/gsumm.c
+++ b/src/gsumm.c
@@ -412,7 +412,8 @@ SEXP gsum(SEXP x, SEXP narmArg, SEXP warnOverflowArg)
     //Rprintf(_("gsum int took %.3f\n"), wallclock()-started);
     if (overflow) {
       UNPROTECT(1); // discard the result with overflow
-      if (warnOverflow) warning(_("The sum of an integer column for a group was more than type 'integer' can hold so the result has been coerced to 'numeric' automatically for convenience."));
+      if (warnOverflow)
+        warning(_("The sum of an integer column for a group was more than type 'integer' can hold so the result has been coerced to 'numeric' automatically for convenience."));
       ans = PROTECT(allocVector(REALSXP, ngrp));
       double *restrict ansp = REAL(ans);
       memset(ansp, 0, ngrp*sizeof(double));
diff --git a/src/rbindlist.c b/src/rbindlist.c
index 08093a7c6c..0fb2690245 100644
--- a/src/rbindlist.c
+++ b/src/rbindlist.c
@@ -243,10 +243,12 @@ SEXP rbindlist(SEXP l, SEXP usenamesArg, SEXP fillArg, SEXP idcolArg)
         }
         const char *o = isNull(opt) ? "message" : CHAR(STRING_ELT(opt,0));
         if      (strcmp(o,"message")==0) { eval(PROTECT(lang2(install("message"),PROTECT(ScalarString(mkChar(buff))))), R_GlobalEnv); UNPROTECT(2); }
-        else if (strcmp(o,"warning")==0) warning(buff);
+        else if (strcmp(o,"warning")==0)
+          warning(buff);
         else if (strcmp(o,"error")==0)
           error(buff);
-        else if (strcmp(o,"none")!=0)    warning(_("options()$datatable.rbindlist.check=='%s' which is not 'message'|'warning'|'error'|'none'. See news item 5 in v1.12.2."), o);
+        else if (strcmp(o,"none")!=0)
+          warning(_("options()$datatable.rbindlist.check=='%s' which is not 'message'|'warning'|'error'|'none'. See news item 5 in v1.12.2."), o);
       }
     }
   }
@@ -538,7 +540,8 @@ SEXP rbindlist(SEXP l, SEXP usenamesArg, SEXP fillArg, SEXP idcolArg)
           }
           // else coerces if needed within memrecycle; with a no-alloc direct coerce from 1.12.4 (PR #3909)
           const char *ret = memrecycle(target, R_NilValue, ansloc, thisnrow, thisCol, 0, -1, idcol+j+1, foundName);
-          if (ret) warning(_("Column %d of item %d: %s"), w+1, i+1, ret);
+          if (ret)
+            warning(_("Column %d of item %d: %s"), w+1, i+1, ret);
           // e.g. when precision is lost like assigning 3.4 to integer64; test 2007.2
           // TODO: but maxType should handle that and this should never warn
         }

From d1f9dc580335420071968ede72256104d99d050b Mon Sep 17 00:00:00 2001
From: Michael Chirico <michael.chirico@grabtaxi.com>
Date: Fri, 13 Mar 2020 15:25:16 +0800
Subject: [PATCH 04/23] done STOP

---
 .dev/CRAN_Release.cmd |   2 +-
 src/forder.c          |  45 ++++++++++++-------
 src/fread.c           | 102 +++++++++++++++++++++++++++++-------------
 src/freadR.c          |  39 ++++++++++------
 src/fwrite.c          |  15 ++++---
 src/fwriteR.c         |   3 +-
 6 files changed, 139 insertions(+), 67 deletions(-)

diff --git a/.dev/CRAN_Release.cmd b/.dev/CRAN_Release.cmd
index 4ef92db8c1..5cda88ce19 100644
--- a/.dev/CRAN_Release.cmd
+++ b/.dev/CRAN_Release.cmd
@@ -157,7 +157,7 @@ grep -P "\t" ./src/*.c
 #   (1) in a comment (pattern: after // or after \s*[*]
 #   (2) in '} else error(' pattern (if else is covered, so is the error)
 #   (3) in #define macros
-for type in error warning; do
+for type in error warning STOP; do
   grep -Enr "\b$type[(]" src --include=*.c | grep -Ev "^src\/[a-zA-Z-]+[.]c:[0-9]+:\s*(?:(?:[}]?\s*else\s*)?$type|#define|[*]|.*\/\/.*$type)"
 done
 
diff --git a/src/forder.c b/src/forder.c
index 66ced36e50..3596a80f9f 100644
--- a/src/forder.c
+++ b/src/forder.c
@@ -103,7 +103,8 @@ static void push(const int *x, const int n) {
   if (gs_thread_alloc[me] < newn) {
     gs_thread_alloc[me] = (newn < nrow/3) ? (1+(newn*2)/4096)*4096 : nrow;  // [2|3] to not overflow and 3 not 2 to avoid allocating close to nrow (nrow groups occurs when all size 1 groups)
     gs_thread[me] = realloc(gs_thread[me], gs_thread_alloc[me]*sizeof(int));
-    if (gs_thread[me]==NULL) STOP(_("Failed to realloc thread private group size buffer to %d*4bytes"), (int)gs_thread_alloc[me]);
+    if (gs_thread[me]==NULL)
+      STOP(_("Failed to realloc thread private group size buffer to %d*4bytes"), (int)gs_thread_alloc[me]);
   }
   memcpy(gs_thread[me]+gs_thread_n[me], x, n*sizeof(int));
   gs_thread_n[me] += n;
@@ -117,7 +118,8 @@ static void flush() {
   if (gs_alloc < newn) {
     gs_alloc = (newn < nrow/3) ? (1+(newn*2)/4096)*4096 : nrow;
     gs = realloc(gs, gs_alloc*sizeof(int));
-    if (gs==NULL) STOP(_("Failed to realloc group size result to %d*4bytes"), (int)gs_alloc);
+    if (gs==NULL)
+      STOP(_("Failed to realloc group size result to %d*4bytes"), (int)gs_alloc);
   }
   memcpy(gs+gs_n, gs_thread[me], n*sizeof(int));
   gs_n += n;
@@ -260,7 +262,8 @@ static void cradix_r(SEXP *xsub, int n, int radix)
     memset(thiscounts, 0, 256*sizeof(int));
     return;
   }
-  if (thiscounts[0] != 0) STOP(_("Logical error. counts[0]=%d in cradix but should have been decremented to 0. radix=%d"), thiscounts[0], radix);
+  if (thiscounts[0] != 0)
+    STOP(_("Logical error. counts[0]=%d in cradix but should have been decremented to 0. radix=%d"), thiscounts[0], radix);
   itmp = 0;
   for (int i=1; i<256; i++) {
     if (thiscounts[i] == 0) continue;
@@ -275,9 +278,11 @@ static void cradix_r(SEXP *xsub, int n, int radix)
 static void cradix(SEXP *x, int n)
 {
   cradix_counts = (int *)calloc(ustr_maxlen*256, sizeof(int));  // counts for the letters of left-aligned strings
-  if (!cradix_counts) STOP(_("Failed to alloc cradix_counts"));
+  if (!cradix_counts)
+    STOP(_("Failed to alloc cradix_counts"));
   cradix_xtmp = (SEXP *)malloc(ustr_n*sizeof(SEXP));
-  if (!cradix_xtmp) STOP(_("Failed to alloc cradix_tmp"));
+  if (!cradix_xtmp)
+    STOP(_("Failed to alloc cradix_tmp"));
   cradix_r(x, n, 0);
   free(cradix_counts); cradix_counts=NULL;
   free(cradix_xtmp);   cradix_xtmp=NULL;
@@ -288,8 +293,10 @@ static void range_str(SEXP *x, int n, uint64_t *out_min, uint64_t *out_max, int
 {
   int na_count=0;
   bool anyneedutf8=false;
-  if (ustr_n!=0) STOP(_("Internal error: ustr isn't empty when starting range_str: ustr_n=%d, ustr_alloc=%d"), ustr_n, ustr_alloc);  // # nocov
-  if (ustr_maxlen!=0) STOP(_("Internal error: ustr_maxlen isn't 0 when starting range_str"));  // # nocov
+  if (ustr_n!=0)
+    STOP(_("Internal error: ustr isn't empty when starting range_str: ustr_n=%d, ustr_alloc=%d"), ustr_n, ustr_alloc);  // # nocov
+  if (ustr_maxlen!=0)
+    STOP(_("Internal error: ustr_maxlen isn't 0 when starting range_str"));  // # nocov
   // savetl_init() has already been called at the start of forder
   #pragma omp parallel for num_threads(getDTthreads())
   for(int i=0; i<n; i++) {
@@ -309,7 +316,8 @@ static void range_str(SEXP *x, int n, uint64_t *out_min, uint64_t *out_max, int
         ustr_alloc = (ustr_alloc==0) ? 16384 : ustr_alloc*2;  // small initial guess, negligible time to alloc 128KB (32 pages)
         if (ustr_alloc>n) ustr_alloc = n;  // clamp at n. Reaches n when fully unique (no dups)
         ustr = realloc(ustr, ustr_alloc * sizeof(SEXP));
-        if (ustr==NULL) STOP(_("Unable to realloc %d * %d bytes in range_str"), ustr_alloc, (int)sizeof(SEXP));  // # nocov
+        if (ustr==NULL)
+          STOP(_("Unable to realloc %d * %d bytes in range_str"), ustr_alloc, (int)sizeof(SEXP));  // # nocov
       }
       ustr[ustr_n++] = s;
       SET_TRUELENGTH(s, -ustr_n);  // unique in any order is fine. first-appearance order is achieved later in count_group
@@ -327,7 +335,8 @@ static void range_str(SEXP *x, int n, uint64_t *out_min, uint64_t *out_max, int
     SEXP ustr2 = PROTECT(allocVector(STRSXP, ustr_n));
     for (int i=0; i<ustr_n; i++) SET_STRING_ELT(ustr2, i, ENC2UTF8(ustr[i]));
     SEXP *ustr3 = (SEXP *)malloc(ustr_n * sizeof(SEXP));
-    if (!ustr3) STOP(_("Failed to alloc ustr3 when converting strings to UTF8"));  // # nocov
+    if (!ustr3)
+      STOP(_("Failed to alloc ustr3 when converting strings to UTF8"));  // # nocov
     memcpy(ustr3, STRING_PTR(ustr2), ustr_n*sizeof(SEXP));
     // need to reset ustr_maxlen because we need ustr_maxlen for utf8 strings
     ustr_maxlen = 0;
@@ -345,7 +354,8 @@ static void range_str(SEXP *x, int n, uint64_t *out_min, uint64_t *out_max, int
     }
     // now use the 1-1 mapping from ustr to ustr2 to get the ordering back into original ustr, being careful to reset tl to 0
     int *tl = (int *)malloc(ustr_n * sizeof(int));
-    if (!tl) STOP(_("Failed to alloc tl when converting strings to UTF8"));  // # nocov
+    if (!tl)
+      STOP(_("Failed to alloc tl when converting strings to UTF8"));  // # nocov
     SEXP *tt = STRING_PTR(ustr2);
     for (int i=0; i<ustr_n; i++) tl[i] = TRUELENGTH(tt[i]);   // fetches the o in ustr3 into tl which is ordered by ustr
     for (int i=0; i<ustr_n; i++) SET_TRUELENGTH(ustr3[i], 0);    // reset to 0 tl of the UTF8 (and possibly non-UTF in ustr too)
@@ -727,12 +737,14 @@ SEXP forder(SEXP DT, SEXP by, SEXP retGrpArg, SEXP sortGroupsArg, SEXP ascArg, S
   int nth = getDTthreads();
   TMP =  (int *)malloc(nth*UINT16_MAX*sizeof(int)); // used by counting sort (my_n<=65536) in radix_r()
   UGRP = (uint8_t *)malloc(nth*256);                // TODO: align TMP and UGRP to cache lines (and do the same for stack allocations too)
-  if (!TMP || !UGRP /*|| TMP%64 || UGRP%64*/) STOP(_("Failed to allocate TMP or UGRP or they weren't cache line aligned: nth=%d"), nth);
+  if (!TMP || !UGRP /*|| TMP%64 || UGRP%64*/)
+    STOP(_("Failed to allocate TMP or UGRP or they weren't cache line aligned: nth=%d"), nth);
   if (retgrp) {
     gs_thread = calloc(nth, sizeof(int *));     // thread private group size buffers
     gs_thread_alloc = calloc(nth, sizeof(int));
     gs_thread_n = calloc(nth, sizeof(int));
-    if (!gs_thread || !gs_thread_alloc || !gs_thread_n) STOP(_("Could not allocate (very tiny) group size thread buffers"));
+    if (!gs_thread || !gs_thread_alloc || !gs_thread_n)
+      STOP(_("Could not allocate (very tiny) group size thread buffers"));
   }
   if (nradix) {
     radix_r(0, nrow-1, 0);  // top level recursive call: (from, to, radix)
@@ -1052,7 +1064,8 @@ void radix_r(const int from, const int to, const int radix) {
   uint16_t *counts = calloc(nBatch*256,sizeof(uint16_t));
   uint8_t  *ugrps =  malloc(nBatch*256*sizeof(uint8_t));
   int      *ngrps =  calloc(nBatch    ,sizeof(int));
-  if (!counts || !ugrps || !ngrps) STOP(_("Failed to allocate parallel counts. my_n=%d, nBatch=%d"), my_n, nBatch);
+  if (!counts || !ugrps || !ngrps)
+    STOP(_("Failed to allocate parallel counts. my_n=%d, nBatch=%d"), my_n, nBatch);
 
   bool skip=true;
   const int n_rem = nradix-radix-1;   // how many radix are remaining after this one
@@ -1161,7 +1174,8 @@ void radix_r(const int from, const int to, const int radix) {
   TEND(18 + notFirst*3)
   if (!skip) {
     int *TMP = malloc(my_n * sizeof(int));
-    if (!TMP) STOP(_("Unable to allocate TMP for my_n=%d items in parallel batch counting"), my_n);
+    if (!TMP)
+      STOP(_("Unable to allocate TMP for my_n=%d items in parallel batch counting"), my_n);
     #pragma omp parallel for num_threads(getDTthreads())
     for (int batch=0; batch<nBatch; batch++) {
       const int *restrict      my_starts = starts + batch*256;
@@ -1268,7 +1282,8 @@ SEXP fsorted(SEXP x)
   // These are all sequential access to x, so very quick and cache efficient. Could be parallel by checking continuity at batch boundaries.
   const int n = length(x);
   if (n <= 1) return(ScalarLogical(TRUE));
-  if (!isVectorAtomic(x)) STOP(_("is.sorted (R level) and fsorted (C level) only to be used on vectors. If needed on a list/data.table, you'll need the order anyway if not sorted, so use if (length(o<-forder(...))) for efficiency in one step, or equivalent at C level"));
+  if (!isVectorAtomic(x))
+    STOP(_("is.sorted (R level) and fsorted (C level) only to be used on vectors. If needed on a list/data.table, you'll need the order anyway if not sorted, so use if (length(o<-forder(...))) for efficiency in one step, or equivalent at C level"));
   int i=1;
   switch(TYPEOF(x)) {
   case INTSXP : case LGLSXP : {
diff --git a/src/fread.c b/src/fread.c
index c94aeac069..530222366c 100644
--- a/src/fread.c
+++ b/src/fread.c
@@ -207,7 +207,8 @@ static char *typeLetter = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopq
 
 static char *typesAsString(int ncol) {
   int nLetters = strlen(typeLetter);
-  if (NUMTYPE>nLetters) STOP(_("Internal error: NUMTYPE(%d) > nLetters(%d)"), NUMTYPE, nLetters); // # nocov
+  if (NUMTYPE>nLetters)
+    STOP(_("Internal error: NUMTYPE(%d) > nLetters(%d)"), NUMTYPE, nLetters); // # nocov
   static char str[101];
   int i=0;
   if (ncol<=100) {
@@ -432,7 +433,8 @@ void copyFile(size_t fileSize, const char *msg, bool verbose)  // only called in
 {
   double tt = wallclock();
   mmp_copy = (char *)malloc((size_t)fileSize + 1/* extra \0 */);
-  if (!mmp_copy) STOP(_("Unable to allocate %s of contiguous virtual RAM. %s allocation."), filesize_to_str(fileSize), msg);
+  if (!mmp_copy)
+    STOP(_("Unable to allocate %s of contiguous virtual RAM. %s allocation."), filesize_to_str(fileSize), msg);
   memcpy(mmp_copy, mmp, fileSize);
   sof = mmp_copy;
   eof = (char *)mmp_copy + fileSize;
@@ -1120,7 +1122,8 @@ int freadMain(freadMainArgs _args) {
 
   int64_t nrowLimit = args.nrowLimit;
   NAstrings = args.NAstrings;
-  if (NAstrings==NULL) STOP(_("Internal error: NAstrings is itself NULL. When empty it should be pointer to NULL.")); // # nocov
+  if (NAstrings==NULL)
+    STOP(_("Internal error: NAstrings is itself NULL. When empty it should be pointer to NULL.")); // # nocov
   any_number_like_NAstrings = false;
   blank_is_a_NAstring = false;
   // if we know there are no nastrings which are numbers (like -999999) then in the number
@@ -1175,10 +1178,14 @@ int freadMain(freadMainArgs _args) {
   fill = args.fill;
   dec = args.dec;
   quote = args.quote;
-  if (args.sep == quote && quote!='\0') STOP(_("sep == quote ('%c') is not allowed"), quote);
-  if (dec=='\0') STOP(_("dec='' not allowed. Should be '.' or ','"));
-  if (args.sep == dec) STOP(_("sep == dec ('%c') is not allowed"), dec);
-  if (quote == dec) STOP(_("quote == dec ('%c') is not allowed"), dec);
+  if (args.sep == quote && quote!='\0')
+    STOP(_("sep == quote ('%c') is not allowed"), quote);
+  if (dec=='\0')
+    STOP(_("dec='' not allowed. Should be '.' or ','"));
+  if (args.sep == dec)
+    STOP(_("sep == dec ('%c') is not allowed"), dec);
+  if (quote == dec)
+    STOP(_("quote == dec ('%c') is not allowed"), dec);
   // since quote=='\0' when user passed quote="", the logic in this file uses '*ch==quote && quote' otherwise
   //   the ending \0 at eof could be treated as a quote (test xxx)
 
@@ -1202,21 +1209,26 @@ int freadMain(freadMainArgs _args) {
     sof = args.input;
     fileSize = strlen(sof);
     eof = sof+fileSize;
-    if (*eof!='\0') STOP(_("Internal error: last byte of character input isn't \\0")); // # nocov
+    if (*eof!='\0')
+      STOP(_("Internal error: last byte of character input isn't \\0")); // # nocov
   }
   else if (args.filename) {
     if (verbose) DTPRINT(_("  Opening file %s\n"), args.filename);
     const char* fnam = args.filename;
     #ifndef WIN32
       int fd = open(fnam, O_RDONLY);
-      if (fd==-1) STOP(_("file not found: %s"),fnam);
+      if (fd==-1)
+        STOP(_("file not found: %s"),fnam);
       struct stat stat_buf;
       if (fstat(fd, &stat_buf) == -1) {
         close(fd);                                                     // # nocov
         STOP(_("Opened file ok but couldn't obtain its size: %s"), fnam); // # nocov
       }
       fileSize = (size_t) stat_buf.st_size;
-      if (fileSize == 0) {close(fd); STOP(_("File is empty: %s"), fnam);}
+      if (fileSize == 0) {
+        close(fd);
+        STOP(_("File is empty: %s"), fnam);
+      }
       if (verbose) DTPRINT(_("  File opened, size = %s.\n"), filesize_to_str(fileSize));
 
       // No MAP_POPULATE for faster nrows=10 and to make possible earlier progress bar in row count stage
@@ -1234,20 +1246,31 @@ int freadMain(freadMainArgs _args) {
         hFile = CreateFile(fnam, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
         // FILE_SHARE_WRITE is required otherwise if the file is open in Excel, CreateFile fails. Should be ok now.
         if (hFile==INVALID_HANDLE_VALUE) {
-          if (GetLastError()==ERROR_FILE_NOT_FOUND) STOP(_("File not found: %s"),fnam);
+          if (GetLastError()==ERROR_FILE_NOT_FOUND)
+            STOP(_("File not found: %s"),fnam);
           if (attempts<4) Sleep(250);  // 250ms
         }
         attempts++;
         // Looped retry to avoid ephemeral locks by system utilities as recommended here : http://support.microsoft.com/kb/316609
       }
-      if (hFile==INVALID_HANDLE_VALUE) STOP(_("Unable to open file after %d attempts (error %d): %s"), attempts, GetLastError(), fnam);
+      if (hFile==INVALID_HANDLE_VALUE)
+        STOP(_("Unable to open file after %d attempts (error %d): %s"), attempts, GetLastError(), fnam);
       LARGE_INTEGER liFileSize;
-      if (GetFileSizeEx(hFile,&liFileSize)==0) { CloseHandle(hFile); STOP(_("GetFileSizeEx failed (returned 0) on file: %s"), fnam); }
+      if (GetFileSizeEx(hFile,&liFileSize)==0) {
+        CloseHandle(hFile);
+        STOP(_("GetFileSizeEx failed (returned 0) on file: %s"), fnam);
+      }
       fileSize = (size_t)liFileSize.QuadPart;
-      if (fileSize<=0) { CloseHandle(hFile); STOP(_("File is empty: %s"), fnam); }
+      if (fileSize<=0) {
+        CloseHandle(hFile);
+        STOP(_("File is empty: %s"), fnam);
+      }
       if (verbose) DTPRINT(_("  File opened, size = %s.\n"), filesize_to_str(fileSize));
       HANDLE hMap=CreateFileMapping(hFile, NULL, PAGE_WRITECOPY, 0, 0, NULL);
-      if (hMap==NULL) { CloseHandle(hFile); STOP(_("This is Windows, CreateFileMapping returned error %d for file %s"), GetLastError(), fnam); }
+      if (hMap==NULL) {
+        CloseHandle(hFile);
+        STOP(_("This is Windows, CreateFileMapping returned error %d for file %s"), GetLastError(), fnam);
+      }
       mmp = MapViewOfFile(hMap,FILE_MAP_COPY,0,0,fileSize);  // fileSize must be <= hilo passed to CreateFileMapping above.
       CloseHandle(hMap);  // we don't need to keep the file open; the MapView keeps an internal reference;
       CloseHandle(hFile); //   see https://msdn.microsoft.com/en-us/library/windows/desktop/aa366537(v=vs.85).aspx
@@ -1297,7 +1320,8 @@ int freadMain(freadMainArgs _args) {
     if (verbose) DTPRINT(_("  Last byte(s) of input found to be %s and removed.\n"),
                          c ? "0x1A (Ctrl+Z)" : "0x00 (NUL)");
   }
-  if (eof<=sof) STOP(_("Input is empty or only contains BOM or terminal control characters"));
+  if (eof<=sof)
+    STOP(_("Input is empty or only contains BOM or terminal control characters"));
   }
 
 
@@ -1383,8 +1407,8 @@ int freadMain(freadMainArgs _args) {
   // like wc -l, head -n and tail -n
   if (args.skipString) {
     ch = strstr(sof, args.skipString);  // as there is now a \0 at the end, this is safely bounded
-    if (!ch) STOP(_("skip='%s' not found in input (it is case sensitive and literal; i.e., no patterns, wildcards or regex)"),
-                  args.skipString);
+    if (!ch)
+      STOP(_("skip='%s' not found in input (it is case sensitive and literal; i.e., no patterns, wildcards or regex)"), args.skipString);
     while (ch>sof && ch[-1]!='\n') ch--;  // move to beginning of line
     pos = ch;
     ch = sof;
@@ -1403,7 +1427,8 @@ int freadMain(freadMainArgs _args) {
       }
     }
     if (ch > sof && verbose) DTPRINT(_("  Skipped to line %"PRIu64" in the file"), (uint64_t)row1line);
-    if (ch>=eof) STOP(_("skip=%"PRIu64" but the input only has %"PRIu64" line%s"), (uint64_t)args.skipNrow, (uint64_t)row1line, row1line>1?"s":"");
+    if (ch>=eof)
+      STOP(_("skip=%"PRIu64" but the input only has %"PRIu64" line%s"), (uint64_t)args.skipNrow, (uint64_t)row1line, row1line>1?"s":"");
     pos = ch;
   }
 
@@ -1412,7 +1437,8 @@ int freadMain(freadMainArgs _args) {
   while (ch<eof && (isspace(*ch) || *ch=='\0')) {   // isspace matches ' ', \t, \n and \r;  \0 before eof should be skipped too
     if (*ch=='\n') { ch++; lineStart=ch; row1line++; } else ch++;
   }
-  if (ch>=eof) STOP(_("Input is either empty, fully whitespace, or skip has been set after the last non-whitespace."));
+  if (ch>=eof)
+    STOP(_("Input is either empty, fully whitespace, or skip has been set after the last non-whitespace."));
   if (verbose) {
     if (lineStart>ch) DTPRINT(_("  Moved forward to first non-blank line (%d)\n"), row1line);
     DTPRINT(_("  Positioned on line %d starting: <<%s>>\n"), row1line, strlim(lineStart, 30));
@@ -1570,7 +1596,8 @@ int freadMain(freadMainArgs _args) {
           topQuoteRule = quoteRule;
         }
       }
-      if (!firstJumpEnd) STOP(_("Single column input contains invalid quotes. Self healing only effective when ncol>1"));
+      if (!firstJumpEnd)
+        STOP(_("Single column input contains invalid quotes. Self healing only effective when ncol>1"));
     }
 
     quoteRule = topQuoteRule;
@@ -1591,10 +1618,12 @@ int freadMain(freadMainArgs _args) {
     }
   }
 
-  if (ncol<1 || row1line<1) STOP(_("Internal error: ncol==%d line==%d after detecting sep, ncol and first line"), ncol, row1line); // # nocov
+  if (ncol<1 || row1line<1)
+    STOP(_("Internal error: ncol==%d line==%d after detecting sep, ncol and first line"), ncol, row1line); // # nocov
   int tt = countfields(&ch);
   ch = pos; // move back to start of line since countfields() moved to next
-  if (!fill && tt!=ncol) STOP(_("Internal error: first line has field count %d but expecting %d"), tt, ncol); // # nocov
+  if (!fill && tt!=ncol)
+    STOP(_("Internal error: first line has field count %d but expecting %d"), tt, ncol); // # nocov
   if (verbose) {
     DTPRINT(_("  Detected %d columns on line %d. This line is either column names or first data row. Line starts as: <<%s>>\n"),
             tt, row1line, strlim(pos, 30));
@@ -1636,7 +1665,8 @@ int freadMain(freadMainArgs _args) {
 
   type =    (int8_t *)malloc((size_t)ncol * sizeof(int8_t));
   tmpType = (int8_t *)malloc((size_t)ncol * sizeof(int8_t));  // used i) in sampling to not stop on errors when bad jump point and ii) when accepting user overrides
-  if (!type || !tmpType) STOP(_("Failed to allocate 2 x %d bytes for type and tmpType: %s"), ncol, strerror(errno));
+  if (!type || !tmpType)
+    STOP(_("Failed to allocate 2 x %d bytes for type and tmpType: %s"), ncol, strerror(errno));
 
   int8_t type0 = 1;
   while (disabled_parsers[type0]) type0++;
@@ -1750,20 +1780,24 @@ int freadMain(freadMainArgs _args) {
     // Maybe previous line (if there is one, prevStart!=NULL) contains column names but there are too few (which is why it didn't become the first data row).
     ch = prevStart;
     int tt = countfields(&ch);
-    if (tt==ncol) STOP(_("Internal error: row before first data row has the same number of fields but we're not using it.")); // # nocov
-    if (ch!=pos)  STOP(_("Internal error: ch!=pos after counting fields in the line before the first data row.")); // # nocov
+    if (tt==ncol)
+      STOP(_("Internal error: row before first data row has the same number of fields but we're not using it.")); // # nocov
+    if (ch!=pos)
+      STOP(_("Internal error: ch!=pos after counting fields in the line before the first data row.")); // # nocov
     if (verbose) DTPRINT(_("Types in 1st data row match types in 2nd data row but previous row has %d fields. Taking previous row as column names."), tt);
     if (tt<ncol) {
       autoFirstColName = (tt==ncol-1);
       DTWARN(_("Detected %d column names but the data has %d columns (i.e. invalid file). Added %d extra default column name%s\n"), tt, ncol, ncol-tt,
              autoFirstColName ? _(" for the first column which is guessed to be row names or an index. Use setnames() afterwards if this guess is not correct, or fix the file write command that created the file to create a valid file.") : _("s at the end."));
     } else if (tt>ncol) {
-      if (fill) STOP(_("Internal error: fill=true but there is a previous row which should already have been filled.")); // # nocov
+      if (fill)
+        STOP(_("Internal error: fill=true but there is a previous row which should already have been filled.")); // # nocov
       DTWARN(_("Detected %d column names but the data has %d columns. Filling rows automatically. Set fill=TRUE explicitly to avoid this warning.\n"), tt, ncol);
       fill = true;
       type =    (int8_t *)realloc(type,    (size_t)tt * sizeof(int8_t));
       tmpType = (int8_t *)realloc(tmpType, (size_t)tt * sizeof(int8_t));
-      if (!type || !tmpType) STOP(_("Failed to realloc 2 x %d bytes for type and tmpType: %s"), tt, strerror(errno));
+      if (!type || !tmpType)
+        STOP(_("Failed to realloc 2 x %d bytes for type and tmpType: %s"), tt, strerror(errno));
       for (int j=ncol; j<tt; j++) { tmpType[j] = type[j] = type0; }
       ncol = tt;
     }
@@ -1834,7 +1868,8 @@ int freadMain(freadMainArgs _args) {
               (uint64_t)allocnrow, (uint64_t)estnrow, (int)(100.0*allocnrow/estnrow-100.0));
       DTPRINT(_("  =====\n"));
     } else {
-      if (sampleLines > allocnrow) STOP(_("Internal error: sampleLines(%"PRIu64") > allocnrow(%"PRIu64")"), (uint64_t)sampleLines, (uint64_t)allocnrow); // # nocov
+      if (sampleLines > allocnrow)
+        STOP(_("Internal error: sampleLines(%"PRIu64") > allocnrow(%"PRIu64")"), (uint64_t)sampleLines, (uint64_t)allocnrow); // # nocov
     }
   }
   if (nrowLimit < allocnrow) {
@@ -1858,7 +1893,8 @@ int freadMain(freadMainArgs _args) {
     colNames = NULL;  // userOverride will assign V1, V2, etc
   } else {
     colNames = (lenOff*) calloc((size_t)ncol, sizeof(lenOff));
-    if (!colNames) STOP(_("Unable to allocate %d*%d bytes for column name pointers: %s"), ncol, sizeof(lenOff), strerror(errno));
+    if (!colNames)
+      STOP(_("Unable to allocate %d*%d bytes for column name pointers: %s"), ncol, sizeof(lenOff), strerror(errno));
     if (sep==' ') while (*ch==' ') ch++;
     void *targets[9] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, colNames + autoFirstColName};
     FieldParseContext fctx = {
@@ -1912,7 +1948,8 @@ int freadMain(freadMainArgs _args) {
   rowSize4 = 0;
   rowSize8 = 0;
   size = (int8_t *)malloc((size_t)ncol * sizeof(int8_t));  // TODO: remove size[] when we implement Pasha's idea to += size inside processor
-  if (!size) STOP(_("Failed to allocate %d bytes for size array: %s"), ncol, strerror(errno));
+  if (!size)
+    STOP(_("Failed to allocate %d bytes for size array: %s"), ncol, strerror(errno));
   nStringCols = 0;
   nNonStringCols = 0;
   for (int j=0; j<ncol; j++) {
@@ -1996,7 +2033,8 @@ int freadMain(freadMainArgs _args) {
   // should only engage when max_nrows is supplied, and supplied small too, so doesn't matter too much.
   if (initialBuffRows < 10) initialBuffRows = 10;
 
-  if (initialBuffRows > INT32_MAX) STOP(_("Buffer size %"PRId64" is too large\n"), (int64_t)initialBuffRows);
+  if (initialBuffRows > INT32_MAX)
+    STOP(_("Buffer size %"PRId64" is too large\n"), (int64_t)initialBuffRows);
   nth = imin(nJumps, nth);
 
   if (verbose) DTPRINT(_("[11] Read the data\n"));
diff --git a/src/freadR.c b/src/freadR.c
index e4c2124a81..392bcae651 100644
--- a/src/freadR.c
+++ b/src/freadR.c
@@ -175,7 +175,8 @@ SEXP freadR(
   dropSxp = dropArg;
   selectColClasses = false;
   if (!isNull(selectSxp)) {
-    if (!isNull(dropSxp)) STOP(_("Use either select= or drop= but not both."));
+    if (!isNull(dropSxp))
+      STOP(_("Use either select= or drop= but not both."));
     if (isNewList(selectArg)) {
       if (!isNull(colClassesSxp))
         STOP(_("select= is type list for specifying types in select=, but colClasses= has been provided as well. Please remove colClasses=."));
@@ -246,8 +247,10 @@ static void applyDrop(SEXP items, int8_t *type, int ncol, int dropSource) {
 bool userOverride(int8_t *type, lenOff *colNames, const char *anchor, const int ncol)
 {
   // use typeSize superfluously to avoid not-used warning; otherwise could move typeSize from fread.h into fread.c
-  if (typeSize[CT_BOOL8_N]!=1) STOP(_("Internal error: typeSize[CT_BOOL8_N] != 1")); // # nocov
-  if (typeSize[CT_STRING]!=8) STOP(_("Internal error: typeSize[CT_STRING] != 1")); // # nocov
+  if (typeSize[CT_BOOL8_N]!=1)
+    STOP(_("Internal error: typeSize[CT_BOOL8_N] != 1")); // # nocov
+  if (typeSize[CT_STRING]!=8)
+    STOP(_("Internal error: typeSize[CT_STRING] != 1")); // # nocov
   colNamesSxp = R_NilValue;
   SET_VECTOR_ELT(RCHK, 1, colNamesSxp=allocVector(STRSXP, ncol));
   for (int i=0; i<ncol; i++) {
@@ -291,10 +294,14 @@ bool userOverride(int8_t *type, lenOff *colNames, const char *anchor, const int
     for (int i=0; i<n; ++i) {
       int k = selectInts[i];
       if (k==NA_INTEGER) continue; // missing column name warned above and skipped
-      if (k<0) STOP(_("Column number %d (select[%d]) is negative but should be in the range [1,ncol=%d]. Consider drop= for column exclusion."),k,i+1,ncol);
-      if (k==0) STOP(_("select = 0 (select[%d]) has no meaning. All values of select should be in the range [1,ncol=%d]."),i+1,ncol);
-      if (k>ncol) STOP(_("Column number %d (select[%d]) is too large for this table, which only has %d columns."),k,i+1,ncol);
-      if (type[k-1]<0) STOP(_("Column number %d ('%s') has been selected twice by select="), k, CHAR(STRING_ELT(colNamesSxp,k-1)));
+      if (k<0)
+        STOP(_("Column number %d (select[%d]) is negative but should be in the range [1,ncol=%d]. Consider drop= for column exclusion."),k,i+1,ncol);
+      if (k==0)
+        STOP(_("select = 0 (select[%d]) has no meaning. All values of select should be in the range [1,ncol=%d]."),i+1,ncol);
+      if (k>ncol)
+        STOP(_("Column number %d (select[%d]) is too large for this table, which only has %d columns."),k,i+1,ncol);
+      if (type[k-1]<0)
+        STOP(_("Column number %d ('%s') has been selected twice by select="), k, CHAR(STRING_ELT(colNamesSxp,k-1)));
       type[k-1] *= -1; // detect and error on duplicates on all types without calling duplicated() at all
       selectRankD[k-1] = rank++;  // rank not i to skip missing column names
     }
@@ -324,9 +331,11 @@ bool userOverride(int8_t *type, lenOff *colNames, const char *anchor, const int
           if (w==NUT) SET_STRING_ELT(colClassesAs, i, tt);
         }
       } else { // selectColClasses==true
-        if (!selectInts) STOP(_("Internal error: selectInts is NULL but selectColClasses is true"));
+        if (!selectInts)
+          STOP(_("Internal error: selectInts is NULL but selectColClasses is true"));
         const int n = length(colClassesSxp);
-        if (length(selectSxp)!=n) STOP(_("Internal error: length(selectSxp)!=length(colClassesSxp) but selectColClasses is true"));
+        if (length(selectSxp)!=n)
+          STOP(_("Internal error: length(selectSxp)!=length(colClassesSxp) but selectColClasses is true"));
         for (int i=0; i<n; ++i) {
           SEXP tt = STRING_ELT(colClassesSxp,i);
           if (tt==NA_STRING || tt==R_BlankString) continue;
@@ -339,9 +348,11 @@ bool userOverride(int8_t *type, lenOff *colNames, const char *anchor, const int
       }
       UNPROTECT(1); // typeEnum_idx
     } else {
-      if (!isNewList(colClassesSxp)) STOP(_("colClasses is type '%s' but should be list or character"), type2char(TYPEOF(colClassesSxp)));
+      if (!isNewList(colClassesSxp))
+        STOP(_("colClasses is type '%s' but should be list or character"), type2char(TYPEOF(colClassesSxp)));
       SEXP listNames = PROTECT(getAttrib(colClassesSxp, R_NamesSymbol));  // rchk wanted this protected
-      if (!length(listNames)) STOP(_("colClasses is type list but has no names"));
+      if (!length(listNames))
+        STOP(_("colClasses is type list but has no names"));
       SEXP typeEnum_idx = PROTECT(chmatch(listNames, typeRName_sxp, NUT));
 
       int *selectRankD = NULL, rank = 1;
@@ -578,7 +589,8 @@ void pushBuffer(ThreadLocalFreadParsingContext *ctx)
         }
       } else
       if (thisSize == 1) {
-        if (type[j] > CT_BOOL8_L) STOP(_("Field size is 1 but the field is of type %d\n"), type[j]);
+        if (type[j] > CT_BOOL8_L)
+          STOP(_("Field size is 1 but the field is of type %d\n"), type[j]);
         Rboolean *dest = (Rboolean *)LOGICAL(VECTOR_ELT(DT, resj)) + DTi;
         const char *src1 = (char*)buff1 + off1;
         for (int i=0; i<nRows; ++i) {
@@ -587,7 +599,8 @@ void pushBuffer(ThreadLocalFreadParsingContext *ctx)
           src1 += rowSize1;
           dest++;
         }
-      } else STOP(_("Internal error: unexpected field of size %d\n"), thisSize);  // # nocov
+      } else
+        STOP(_("Internal error: unexpected field of size %d\n"), thisSize);  // # nocov
       done++;
     }
     off8 += (size[j] & 8);
diff --git a/src/fwrite.c b/src/fwrite.c
index cf58c2581b..011e0af699 100644
--- a/src/fwrite.c
+++ b/src/fwrite.c
@@ -610,14 +610,16 @@ void fwriteMain(fwriteMainArgs args)
   qmethodEscape = args.qmethodEscape;
   squashDateTime = args.squashDateTime;
 
-  if (args.buffMB<1 || args.buffMB>1024) STOP(_("buffMB=%d outside [1,1024]"), args.buffMB);
+  if (args.buffMB<1 || args.buffMB>1024)
+    STOP(_("buffMB=%d outside [1,1024]"), args.buffMB);
   size_t buffSize = (size_t)1024*1024*args.buffMB;
 
   int eolLen=strlen(args.eol), naLen=strlen(args.na);
   // Aside: codacy wants strnlen but strnlen is not in C99 (neither is strlen_s). To pass `gcc -std=c99 -Wall -pedantic`
   //        we'd need `#define _POSIX_C_SOURCE 200809L` before #include <string.h> but that seems a step too far
   //        and platform specific. We prefer to be pure C99.
-  if (eolLen<=0) STOP(_("eol must be 1 or more bytes (usually either \\n or \\r\\n) but is length %d"), eolLen);
+  if (eolLen<=0)
+    STOP(_("eol must be 1 or more bytes (usually either \\n or \\r\\n) but is length %d"), eolLen);
 
   if (verbose) {
     DTPRINT(_("Column writers: "));
@@ -710,7 +712,8 @@ void fwriteMain(fwriteMainArgs args)
   }
   if (headerLen) {
     char *buff = malloc(headerLen);
-    if (!buff) STOP(_("Unable to allocate %d MiB for header: %s"), headerLen / 1024 / 1024, strerror(errno));
+    if (!buff)
+      STOP(_("Unable to allocate %d MiB for header: %s"), headerLen / 1024 / 1024, strerror(errno));
     char *ch = buff;
     if (args.bom) {*ch++=(char)0xEF; *ch++=(char)0xBB; *ch++=(char)0xBF; }  // 3 appears above (search for "bom")
     memcpy(ch, args.yaml, yamlLen);
@@ -761,7 +764,8 @@ void fwriteMain(fwriteMainArgs args)
         // # nocov start
         int errwrite = errno; // capture write errno now incase close fails with a different errno
         CLOSE(f);
-        if (ret1) STOP(_("Compress gzip error: %d"), ret1);
+        if (ret1)
+          STOP(_("Compress gzip error: %d"), ret1);
         else      STOP(_("%s: '%s'"), strerror(errwrite), args.filename);
         // # nocov end
       }
@@ -770,7 +774,8 @@ void fwriteMain(fwriteMainArgs args)
   if (verbose) DTPRINT(_("done in %.3fs\n"), 1.0*(wallclock()-t0));
   if (args.nrow == 0) {
     if (verbose) DTPRINT(_("No data rows present (nrow==0)\n"));
-    if (f!=-1 && CLOSE(f)) STOP(_("%s: '%s'"), strerror(errno), args.filename);
+    if (f!=-1 && CLOSE(f))
+      STOP(_("%s: '%s'"), strerror(errno), args.filename);
     return;
   }
 
diff --git a/src/fwriteR.c b/src/fwriteR.c
index 911e3e22fa..2d15f53d6b 100644
--- a/src/fwriteR.c
+++ b/src/fwriteR.c
@@ -101,7 +101,8 @@ int getMaxListItemLen(const SEXP *col, const int64_t n) {
     }
     int width = writerMaxLen[wf];
     if (width==0) {
-      if (wf!=WF_String) STOP(_("Internal error: row %"PRId64" of list column has no max length method implemented"), i+1); // # nocov
+      if (wf!=WF_String)
+        STOP(_("Internal error: row %"PRId64" of list column has no max length method implemented"), i+1); // # nocov
       const int l = LENGTH(this);
       for (int j=0; j<l; ++j) width+=LENGTH(STRING_ELT(this, j));
     } else {

From 806a58082774d32994f971d1281b4d6ed0a68aec Mon Sep 17 00:00:00 2001
From: Michael Chirico <michael.chirico@grabtaxi.com>
Date: Fri, 13 Mar 2020 15:26:03 +0800
Subject: [PATCH 05/23] nothing for DTWARN

---
 .dev/CRAN_Release.cmd | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.dev/CRAN_Release.cmd b/.dev/CRAN_Release.cmd
index 5cda88ce19..48bfa28eab 100644
--- a/.dev/CRAN_Release.cmd
+++ b/.dev/CRAN_Release.cmd
@@ -157,7 +157,7 @@ grep -P "\t" ./src/*.c
 #   (1) in a comment (pattern: after // or after \s*[*]
 #   (2) in '} else error(' pattern (if else is covered, so is the error)
 #   (3) in #define macros
-for type in error warning STOP; do
+for type in error warning STOP DTWARN; do
   grep -Enr "\b$type[(]" src --include=*.c | grep -Ev "^src\/[a-zA-Z-]+[.]c:[0-9]+:\s*(?:(?:[}]?\s*else\s*)?$type|#define|[*]|.*\/\/.*$type)"
 done
 

From 77e87622fe5db31e2b08a8535fac08aab6730b7c Mon Sep 17 00:00:00 2001
From: Michael Chirico <michael.chirico@grabtaxi.com>
Date: Sat, 14 Mar 2020 11:49:21 +0800
Subject: [PATCH 06/23] adding some coverage tests for newly uncovered lines

---
 .dev/CRAN_Release.cmd |  2 +-
 inst/tests/tests.Rraw | 21 +++++++++++++++++++
 src/assign.c          | 48 +++++++++++++++++++++++++------------------
 src/init.c            | 26 +++++++++++------------
 src/utils.c           |  2 +-
 5 files changed, 64 insertions(+), 35 deletions(-)

diff --git a/.dev/CRAN_Release.cmd b/.dev/CRAN_Release.cmd
index 48bfa28eab..ab215750d6 100644
--- a/.dev/CRAN_Release.cmd
+++ b/.dev/CRAN_Release.cmd
@@ -157,7 +157,7 @@ grep -P "\t" ./src/*.c
 #   (1) in a comment (pattern: after // or after \s*[*]
 #   (2) in '} else error(' pattern (if else is covered, so is the error)
 #   (3) in #define macros
-for type in error warning STOP DTWARN; do
+for type in error warning STOP DTWARN Error; do
   grep -Enr "\b$type[(]" src --include=*.c | grep -Ev "^src\/[a-zA-Z-]+[.]c:[0-9]+:\s*(?:(?:[}]?\s*else\s*)?$type|#define|[*]|.*\/\/.*$type)"
 done
 
diff --git a/inst/tests/tests.Rraw b/inst/tests/tests.Rraw
index 7cc6819e8f..59167e7a71 100644
--- a/inst/tests/tests.Rraw
+++ b/inst/tests/tests.Rraw
@@ -16846,3 +16846,24 @@ A = data.table(A=c(complex(real = 1:3, imaginary=c(0, -1, 1)), NaN))
 test(2138.3, rbind(A,B), data.table(A=c(as.character(A$A), B$A)))
 A = data.table(A=as.complex(rep(NA, 5)))
 test(2138.4, rbind(A,B), data.table(A=c(as.character(A$A), B$A)))
+
+# tests caught by introducing newlines in #4301
+test(2139.01, getDTthreads(8L), error='verbose must be TRUE or FALSE')
+test(2139.02, setDTthreads(1:2), error='threads= must be either NULL.*length 2')
+test(2139.03, setDTthreads(1+0i), error='threads= must be either NULL.*type integer/numeric')
+DT = data.table(1)
+alloc.col(DT, 10010L)
+test(2139.04, alloc.col(DT), DT, warning='greater than 10,000 items over-allocated')
+test(2139.05, alloc.col(DT, verbose = 1L), error="verbose must be TRUE or FALSE")
+test(2139.06, set(data.table(NULL, NULL, 1L, 1L)), error="Input data.table has no columns")
+test(2139.07, set(1L, NULL, 1L, 1L), error="object passed to assign isn't type VECSXP")
+names(DT) = NULL
+test(2139.08, set(DT, NULL, 1L, 2L), error="data.table passed to assign has no names")
+test(2139.09, alloc.col(NULL), error="object passed to alloc.col is NULL")
+test(2139.10, set(NULL, NULL, 1L, 1L), error="object passed to assign is NULL")
+setDF(DT)
+names(DT) = 'V1'
+test(2139.11, set(DT, NULL, 'V2', 2L), error="set() on a data.frame is for changing existing columns")
+setDT(DT)
+alloc.col(DT, 10010L)
+test(2139.12, set(DT, NULL, 'V2', 2L), DT, warning="greater than 10,000 items over-allocated")
diff --git a/src/assign.c b/src/assign.c
index cacfa56d7a..787b5e5bb6 100644
--- a/src/assign.c
+++ b/src/assign.c
@@ -198,15 +198,14 @@ static SEXP shallow(SEXP dt, SEXP cols, R_len_t n)
 
 SEXP alloccol(SEXP dt, R_len_t n, Rboolean verbose)
 {
-  SEXP names, klass;   // klass not class at request of pydatatable because class is reserved word in C++, PR #3129
+  SEXP names;
   R_len_t l, tl;
   if (isNull(dt))
-    error(_("alloccol has been passed a NULL dt"));
+    error(_("object passed to alloccol is NULL"));
   if (TYPEOF(dt) != VECSXP)
-    error(_("dt passed to alloccol isn't type VECSXP"));
-  klass = getAttrib(dt, R_ClassSymbol);
-  if (isNull(klass))
-    error(_("dt passed to alloccol has no class attribute. Please report result of traceback() to data.table issue tracker."));
+    error(_("object passed to alloccol isn't type VECSXP"));
+  if (isNull(getAttrib(dt, R_ClassSymbol)))
+    error(_("Internal error: data.table passed to alloccol has no class attribute and is not NULL. Please report result of traceback() to data.table issue tracker."));
   l = LENGTH(dt);
   names = getAttrib(dt,R_NamesSymbol);
   // names may be NULL when null.data.table() passes list() to alloccol for example.
@@ -299,9 +298,9 @@ SEXP assign(SEXP dt, SEXP rows, SEXP cols, SEXP newcolnames, SEXP values)
   const char *c1, *tc1, *tc2;
   int *buf, newKeyLength, indexNo;
   if (isNull(dt))
-    error(_("assign has been passed a NULL dt"));
+    error(_("object passed to assign is NULL"));
   if (TYPEOF(dt) != VECSXP)
-    error(_("dt passed to assign isn't type VECSXP"));
+    error(_("object passed to assign isn't type VECSXP"));
   if (islocked(dt))
     error(_(".SD is locked. Updating .SD by reference using := or set are reserved for future use. Use := in j directly. Or use copy(.SD) as a (slow) last resort, until shallow() is exported."));
 
@@ -316,7 +315,7 @@ SEXP assign(SEXP dt, SEXP rows, SEXP cols, SEXP newcolnames, SEXP values)
   oldncol = LENGTH(dt);
   SEXP names = PROTECT(getAttrib(dt, R_NamesSymbol)); protecti++;
   if (isNull(names))
-    error(_("dt passed to assign has no names"));
+    error(_("data.table passed to assign has no names"));
   if (length(names)!=oldncol)
     error(_("Internal error in assign: length of names (%d) is not length of dt (%d)"),length(names),oldncol); // # nocov
   if (isNull(dt)) {
@@ -393,7 +392,7 @@ SEXP assign(SEXP dt, SEXP rows, SEXP cols, SEXP newcolnames, SEXP values)
   if (any_duplicated(cols,FALSE))
     error(_("Can't assign to the same column twice in the same query (duplicates detected)."));
   if (!isNull(newcolnames) && !isString(newcolnames))
-    error(_("newcolnames is supplied but isn't a character vector"));
+    error(_("Internal error: newcolnames is supplied but isn't a character vector")); // # nocov
   bool RHS_list_of_columns = TYPEOF(values)==VECSXP && length(cols)>1;  // initial value; may be revised below
   if (verbose) Rprintf(_("RHS_list_of_columns == %s\n"), RHS_list_of_columns ? "true" : "false");
   if (TYPEOF(values)==VECSXP && length(cols)==1 && length(values)==1) {
@@ -422,8 +421,13 @@ SEXP assign(SEXP dt, SEXP rows, SEXP cols, SEXP newcolnames, SEXP values)
     if (coln<1 || coln>oldncol+length(newcolnames)) {
       if (!isDataTable)
         error(_("Item %d of column numbers in j is %d which is outside range [1,ncol=%d]. set() on a data.frame is for changing existing columns, not adding new ones. Please use a data.table for that."), i+1, coln, oldncol);
-      else
-        error(_("Item %d of column numbers in j is %d which is outside range [1,ncol=%d]. Use column names instead in j to add new columns."), i+1, coln, oldncol);
+      else {
+        if (oldncol >= 1) {
+          error(_("Item %d of column numbers in j is %d which is outside range [1,ncol=%d]. Use column names instead in j to add new columns."), i+1, coln, oldncol);
+        } else {
+          error(_("Input data.table has no columns. Use column names in j instead to add new columns."));
+        }
+      }
     }
     coln--;
     SEXP thisvalue = RHS_list_of_columns ? VECTOR_ELT(values, i) : values;
@@ -1230,21 +1234,25 @@ void savetl_end() {
   nsaved = nalloc = 0;
 }
 
+// Not exposed to users and only called from:
+//   [.data.table->.massageSD
+//   setnames
 SEXP setcharvec(SEXP x, SEXP which, SEXP newx)
 {
-  int w;
   if (!isString(x))
-    error(_("x must be a character vector"));
+    error(_("Internal error: x must be a character vector in setcharvec")); // # nocov
   if (!isInteger(which))
-    error(_("'which' must be an integer vector"));
+    error(_("Internal error: 'which' must be an integer vector in setcharvec")); // # nocov
   if (!isString(newx))
-    error(_("'new' must be a character vector"));
+    error(_("Internal error: 'new' must be a character vector in setcharvec")); // # nocov
   if (LENGTH(newx)!=LENGTH(which))
-    error(_("'new' is length %d. Should be the same as length of 'which' (%d)"),LENGTH(newx),LENGTH(which));
+    error(_("Internal error: 'new' is length %d. Should be the same as length of 'which' (%d) in setcharvec"),LENGTH(newx),LENGTH(which)); // # nocov
+  int *wp = INTEGER(which);
+  int n = LENGTH(x);s
   for (int i=0; i<LENGTH(which); i++) {
-    w = INTEGER(which)[i];
-    if (w==NA_INTEGER || w<1 || w>LENGTH(x))
-      error(_("Item %d of 'which' is %d which is outside range of the length %d character vector"), i+1,w,LENGTH(x));
+    int w = wp[i];
+    if (w==NA_INTEGER || w<1 || w>n)
+      error(_("Internal error: Item %d of 'which' is %d which is outside range of the length %d character vector in setcharvec"), i+1,w,LENGTH(x)); // # nocov
     SET_STRING_ELT(x, w-1, STRING_ELT(newx, i));
   }
   return R_NilValue;
diff --git a/src/init.c b/src/init.c
index 6b56bd27da..1a78d5bb27 100644
--- a/src/init.c
+++ b/src/init.c
@@ -246,7 +246,7 @@ void attribute_visible R_init_datatable(DllInfo *info)
   setSizes();
   const char *msg = "... failed. Please forward this message to maintainer('data.table').";
   if ((int)NA_INTEGER != (int)INT_MIN)
-    error(_("Checking NA_INTEGER [%d] == INT_MIN [%d] %s"), NA_INTEGER, INT_MIN, msg);
+    error(_("Checking NA_INTEGER [%d] == INT_MIN [%d] %s"), NA_INTEGER, INT_MIN, msg); // # nocov
   if ((int)NA_INTEGER != (int)NA_LOGICAL)
     error(_("Checking NA_INTEGER [%d] == NA_LOGICAL [%d] %s"), NA_INTEGER, NA_LOGICAL, msg);
   if (sizeof(int) != 4)
@@ -277,9 +277,9 @@ void attribute_visible R_init_datatable(DllInfo *info)
 
   SEXP tmp = PROTECT(allocVector(INTSXP,2));
   if (LENGTH(tmp)!=2)
-    error(_("Checking LENGTH(allocVector(INTSXP,2)) [%d] is 2 %s"), LENGTH(tmp), msg);
+    error(_("Checking LENGTH(allocVector(INTSXP,2)) [%d] is 2 %s"), LENGTH(tmp), msg); // # nocov
   if (TRUELENGTH(tmp)!=0)
-    error(_("Checking TRUELENGTH(allocVector(INTSXP,2)) [%d] is 0 %s"), TRUELENGTH(tmp), msg);
+    error(_("Checking TRUELENGTH(allocVector(INTSXP,2)) [%d] is 0 %s"), TRUELENGTH(tmp), msg); // # nocov
   UNPROTECT(1);
 
   // According to IEEE (http://en.wikipedia.org/wiki/IEEE_754-1985#Zero) we can rely on 0.0 being all 0 bits.
@@ -287,19 +287,19 @@ void attribute_visible R_init_datatable(DllInfo *info)
   int i = 314;
   memset(&i, 0, sizeof(int));
   if (i != 0)
-    error(_("Checking memset(&i,0,sizeof(int)); i == (int)0 %s"), msg);
+    error(_("Checking memset(&i,0,sizeof(int)); i == (int)0 %s"), msg); // # nocov
   unsigned int ui = 314;
   memset(&ui, 0, sizeof(unsigned int));
   if (ui != 0)
-    error(_("Checking memset(&ui, 0, sizeof(unsigned int)); ui == (unsigned int)0 %s"), msg);
+    error(_("Checking memset(&ui, 0, sizeof(unsigned int)); ui == (unsigned int)0 %s"), msg); // # nocov
   double d = 3.14;
   memset(&d, 0, sizeof(double));
   if (d != 0.0)
-    error(_("Checking memset(&d, 0, sizeof(double)); d == (double)0.0 %s"), msg);
+    error(_("Checking memset(&d, 0, sizeof(double)); d == (double)0.0 %s"), msg); // # nocov
   long double ld = 3.14;
   memset(&ld, 0, sizeof(long double));
   if (ld != 0.0)
-    error(_("Checking memset(&ld, 0, sizeof(long double)); ld == (long double)0.0 %s"), msg);
+    error(_("Checking memset(&ld, 0, sizeof(long double)); ld == (long double)0.0 %s"), msg); // # nocov
 
   // Check unsigned cast used in fread.c. This isn't overflow/underflow, just cast.
   if ((uint_fast8_t)('0'-'/') != 1)
@@ -315,18 +315,18 @@ void attribute_visible R_init_datatable(DllInfo *info)
   NA_INT64_LL = LLONG_MIN;
   NA_INT64_D = LLtoD(NA_INT64_LL);
   if (NA_INT64_LL != DtoLL(NA_INT64_D))
-    error(_("Conversion of NA_INT64 via double failed %"PRId64"!=%"PRId64), (int64_t)NA_INT64_LL, (int64_t)DtoLL(NA_INT64_D));
+    error(_("Conversion of NA_INT64 via double failed %"PRId64"!=%"PRId64), (int64_t)NA_INT64_LL, (int64_t)DtoLL(NA_INT64_D)); // # nocov
   // LLONG_MIN when punned to double is the sign bit set and then all zeros in exponent and significand i.e. -0.0
   //   That's why we must never test for NA_INT64_D using == in double type. Must always DtoLL and compare long long types.
   //   Assigning NA_INT64_D to a REAL is ok however.
   if (NA_INT64_D != 0.0)
-    error(_("NA_INT64_D (negative -0.0) is not == 0.0."));
+    error(_("NA_INT64_D (negative -0.0) is not == 0.0.")); // # nocov
   if (NA_INT64_D != -0.0)
-    error(_("NA_INT64_D (negative -0.0) is not ==-0.0."));
+    error(_("NA_INT64_D (negative -0.0) is not ==-0.0.")); // # nocov
   if (ISNAN(NA_INT64_D))
-    error(_("ISNAN(NA_INT64_D) is TRUE but should not be"));
+    error(_("ISNAN(NA_INT64_D) is TRUE but should not be")); // # nocov
   if (isnan(NA_INT64_D))
-    error(_("isnan(NA_INT64_D) is TRUE but should not be"));
+    error(_("isnan(NA_INT64_D) is TRUE but should not be")); // # nocov
 
   NA_CPLX.r = NA_REAL;  // NA_REAL is defined as R_NaReal which is not a strict constant and thus initializer {NA_REAL, NA_REAL} can't be used in .h
   NA_CPLX.i = NA_REAL;  // https://github.com/Rdatatable/data.table/pull/3689/files#r304117234
@@ -425,7 +425,7 @@ extern int *_Last_updated;  // assign.c
 
 SEXP initLastUpdated(SEXP var) {
   if (!isInteger(var) || LENGTH(var)!=1)
-    error(_(".Last.value in namespace is not a length 1 integer"));
+    error(_("Internal error: .Last.value in namespace is not a length 1 integer")); // # nocov
   _Last_updated = INTEGER(var);
   return R_NilValue;
 }
diff --git a/src/utils.c b/src/utils.c
index 4a07bdcec2..0e99c0ab39 100644
--- a/src/utils.c
+++ b/src/utils.c
@@ -206,7 +206,7 @@ inline bool INHERITS(SEXP x, SEXP char_) {
   // Thread safe in the limited sense of correct and intended usage :
   // i) no API call such as install() or mkChar() must be passed in.
   // ii) no attrib writes must be possible in other threads.
-  SEXP klass;
+  SEXP klass; // klass not class at request of pydatatable because class is reserved word in C++, PR #3129
   if (isString(klass = getAttrib(x, R_ClassSymbol))) {
     for (int i=0; i<LENGTH(klass); i++) {
       if (STRING_ELT(klass, i) == char_) return true;

From 1d5c7ac5b08c21da4a6160425071ba772cdc9a7d Mon Sep 17 00:00:00 2001
From: Michael Chirico <michael.chirico@grabtaxi.com>
Date: Sat, 14 Mar 2020 12:25:46 +0800
Subject: [PATCH 07/23] typo

---
 src/assign.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/assign.c b/src/assign.c
index 787b5e5bb6..c92cc38a4c 100644
--- a/src/assign.c
+++ b/src/assign.c
@@ -1248,7 +1248,7 @@ SEXP setcharvec(SEXP x, SEXP which, SEXP newx)
   if (LENGTH(newx)!=LENGTH(which))
     error(_("Internal error: 'new' is length %d. Should be the same as length of 'which' (%d) in setcharvec"),LENGTH(newx),LENGTH(which)); // # nocov
   int *wp = INTEGER(which);
-  int n = LENGTH(x);s
+  int n = LENGTH(x);
   for (int i=0; i<LENGTH(which); i++) {
     int w = wp[i];
     if (w==NA_INTEGER || w<1 || w>n)

From 876f693f519414e9d53e92e34f9f7d59503cda2e Mon Sep 17 00:00:00 2001
From: Michael Chirico <michael.chirico@grabtaxi.com>
Date: Sat, 14 Mar 2020 18:11:42 +0800
Subject: [PATCH 08/23] small fixes

---
 inst/tests/tests.Rraw | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/inst/tests/tests.Rraw b/inst/tests/tests.Rraw
index 59167e7a71..ab92a65bfc 100644
--- a/inst/tests/tests.Rraw
+++ b/inst/tests/tests.Rraw
@@ -16848,22 +16848,22 @@ A = data.table(A=as.complex(rep(NA, 5)))
 test(2138.4, rbind(A,B), data.table(A=c(as.character(A$A), B$A)))
 
 # tests caught by introducing newlines in #4301
-test(2139.01, getDTthreads(8L), error='verbose must be TRUE or FALSE')
+test(2139.01, getDTthreads(8L), error="'verbose' must be TRUE or FALSE")
 test(2139.02, setDTthreads(1:2), error='threads= must be either NULL.*length 2')
 test(2139.03, setDTthreads(1+0i), error='threads= must be either NULL.*type integer/numeric')
 DT = data.table(1)
-alloc.col(DT, 10010L)
+invisible(alloc.col(DT, 10010L))
 test(2139.04, alloc.col(DT), DT, warning='greater than 10,000 items over-allocated')
 test(2139.05, alloc.col(DT, verbose = 1L), error="verbose must be TRUE or FALSE")
-test(2139.06, set(data.table(NULL, NULL, 1L, 1L)), error="Input data.table has no columns")
+test(2139.06, set(data.table(NULL), NULL, 1L, 1L), error="Input data.table has no columns")
 test(2139.07, set(1L, NULL, 1L, 1L), error="object passed to assign isn't type VECSXP")
 names(DT) = NULL
 test(2139.08, set(DT, NULL, 1L, 2L), error="data.table passed to assign has no names")
-test(2139.09, alloc.col(NULL), error="object passed to alloc.col is NULL")
+test(2139.09, alloc.col(NULL), error="object passed to alloccol is NULL")
 test(2139.10, set(NULL, NULL, 1L, 1L), error="object passed to assign is NULL")
 setDF(DT)
 names(DT) = 'V1'
 test(2139.11, set(DT, NULL, 'V2', 2L), error="set() on a data.frame is for changing existing columns")
 setDT(DT)
-alloc.col(DT, 10010L)
+invisible(alloc.col(DT, 10010L))
 test(2139.12, set(DT, NULL, 'V2', 2L), DT, warning="greater than 10,000 items over-allocated")

From 1b0122ea6134c1ae8281543d1c78aa66e2e4ea9e Mon Sep 17 00:00:00 2001
From: Michael Chirico <michael.chirico@grabtaxi.com>
Date: Sat, 14 Mar 2020 19:23:44 +0800
Subject: [PATCH 09/23] more tests

---
 inst/tests/tests.Rraw | 17 +++++++++++++----
 src/assign.c          |  2 +-
 src/fmelt.c           | 22 +++++++++++++++-------
 src/forder.c          | 22 +++++++++++-----------
 src/fread.c           | 13 +++++++------
 src/fwriteR.c         |  4 ++--
 src/rbindlist.c       | 16 ++++++++--------
 7 files changed, 57 insertions(+), 39 deletions(-)

diff --git a/inst/tests/tests.Rraw b/inst/tests/tests.Rraw
index ab92a65bfc..0de19bf701 100644
--- a/inst/tests/tests.Rraw
+++ b/inst/tests/tests.Rraw
@@ -16851,7 +16851,7 @@ test(2138.4, rbind(A,B), data.table(A=c(as.character(A$A), B$A)))
 test(2139.01, getDTthreads(8L), error="'verbose' must be TRUE or FALSE")
 test(2139.02, setDTthreads(1:2), error='threads= must be either NULL.*length 2')
 test(2139.03, setDTthreads(1+0i), error='threads= must be either NULL.*type integer/numeric')
-DT = data.table(1)
+DT = data.table(1L)
 invisible(alloc.col(DT, 10010L))
 test(2139.04, alloc.col(DT), DT, warning='greater than 10,000 items over-allocated')
 test(2139.05, alloc.col(DT, verbose = 1L), error="verbose must be TRUE or FALSE")
@@ -16860,10 +16860,19 @@ test(2139.07, set(1L, NULL, 1L, 1L), error="object passed to assign isn't type V
 names(DT) = NULL
 test(2139.08, set(DT, NULL, 1L, 2L), error="data.table passed to assign has no names")
 test(2139.09, alloc.col(NULL), error="object passed to alloccol is NULL")
-test(2139.10, set(NULL, NULL, 1L, 1L), error="object passed to assign is NULL")
+test(2139.10, alloc.col(1L), error="object passed to allocco isn't type VECSXP")
+test(2139.11, set(NULL, NULL, 1L, 1L), error="object passed to assign is NULL")
 setDF(DT)
 names(DT) = 'V1'
-test(2139.11, set(DT, NULL, 'V2', 2L), error="set() on a data.frame is for changing existing columns")
+test(2139.12, set(DT, NULL, 'V2', 2L), error="set() on a data.frame is for changing existing columns")
 setDT(DT)
 invisible(alloc.col(DT, 10010L))
-test(2139.12, set(DT, NULL, 'V2', 2L), DT, warning="greater than 10,000 items over-allocated")
+test(2139.13, set(DT, NULL, 'V2', 2L), DT, warning="greater than 10,000 items over-allocated")
+
+txt = 'a,b\n1,2'
+test(2139.14, fread(txt, sep=',', quote=','), error="sep == quote (',') is not allowed")
+test(2139.15, fread(txt, dec='&'), error="dec='&' not allowed")
+test(2139.16, fread(txt, quote='.', dec='.'), error="quote == dec ('.') is not allowed")
+
+test(2139.17, setNumericRounding(1:2), error="Rounding level must be a length-1 integer or numeric vector")
+test(2139.18, setNumericRounding(-1), error="Rounding level must be 2, 1 or 0")
diff --git a/src/assign.c b/src/assign.c
index c92cc38a4c..4f57c383b7 100644
--- a/src/assign.c
+++ b/src/assign.c
@@ -205,7 +205,7 @@ SEXP alloccol(SEXP dt, R_len_t n, Rboolean verbose)
   if (TYPEOF(dt) != VECSXP)
     error(_("object passed to alloccol isn't type VECSXP"));
   if (isNull(getAttrib(dt, R_ClassSymbol)))
-    error(_("Internal error: data.table passed to alloccol has no class attribute and is not NULL. Please report result of traceback() to data.table issue tracker."));
+    error(_("Internal error: data.table passed to alloccol has no class attribute and is not NULL. Please report result of traceback() to data.table issue tracker.")); // # nocov
   l = LENGTH(dt);
   names = getAttrib(dt,R_NamesSymbol);
   // names may be NULL when null.data.table() passes list() to alloccol for example.
diff --git a/src/fmelt.c b/src/fmelt.c
index 7ae1c69dcc..bdd23d35a2 100644
--- a/src/fmelt.c
+++ b/src/fmelt.c
@@ -18,7 +18,7 @@ SEXP set_diff(SEXP x, int n) {
   if (TYPEOF(x) != INTSXP)
     error(_("'x' must be an integer"));
   if (n <= 0)
-    error(_("'n' must be a positive integer"));
+    error(_("Internal error: n must be a positive integer in set_diff")); // # nocov
   SEXP table = PROTECT(seq_int(n, 1));       // TODO: using match to 1:n seems odd here, why use match at all
   SEXP xmatch = PROTECT(match(x, table, 0)); // Old comment:took a while to realise: matches vec against x - thanks to comment from Matt in assign.c!
   const int *ixmatch = INTEGER(xmatch);
@@ -168,10 +168,13 @@ SEXP checkVars(SEXP DT, SEXP id, SEXP measure, Rboolean verbose) {
       else continue;
     }
     unqtmp = PROTECT(allocVector(INTSXP, targetcols)); protecti++;
+    int *up = INTEGER(unqtmp);
+    int *tp = INTEGER(tmp);
+    int *bp = LOGICAL(booltmp);
     u = 0;
     for (i=0; i<length(booltmp); i++) {
-      if (!LOGICAL(booltmp)[i]) {
-        INTEGER(unqtmp)[u++] = INTEGER(tmp)[i];
+      if (!bp[i]) {
+        up[u++] = tp[i];
       }
     }
     tmp2 = PROTECT(set_diff(unqtmp, ncol)); protecti++;
@@ -196,17 +199,22 @@ SEXP checkVars(SEXP DT, SEXP id, SEXP measure, Rboolean verbose) {
       tmp = PROTECT(unlist_(tmp2)); protecti++;
     }
     booltmp = PROTECT(duplicated(tmp, FALSE)); protecti++;
+    int *tp = INTEGER(tmp);
+    int *bp = LOGICAL(booltmp);
     for (i=0; i<length(tmp); i++) {
-      if (INTEGER(tmp)[i] <= 0 || INTEGER(tmp)[i] > ncol)
+      if (tp[i] <= 0 || tp[i] > ncol)
         error(_("One or more values in 'measure.vars' is invalid."));
-      else if (!LOGICAL(booltmp)[i]) targetcols++;
+      else if (!bp[i]) targetcols++;
       else continue;
     }
     unqtmp = PROTECT(allocVector(INTSXP, targetcols)); protecti++;
+    int *up = INTEGER(unqtmp);
+    tp = INTEGER(tmp);
+    bp = LOGICAL(booltmp);
     u = 0;
     for (i=0; i<length(booltmp); i++) {
-      if (!LOGICAL(booltmp)[i]) {
-        INTEGER(unqtmp)[u++] = INTEGER(tmp)[i];
+      if (!bp[i]) {
+        up[u++] = tp[i];
       }
     }
     idcols = PROTECT(set_diff(unqtmp, ncol)); protecti++;
diff --git a/src/forder.c b/src/forder.c
index 3596a80f9f..d11252e84b 100644
--- a/src/forder.c
+++ b/src/forder.c
@@ -104,7 +104,7 @@ static void push(const int *x, const int n) {
     gs_thread_alloc[me] = (newn < nrow/3) ? (1+(newn*2)/4096)*4096 : nrow;  // [2|3] to not overflow and 3 not 2 to avoid allocating close to nrow (nrow groups occurs when all size 1 groups)
     gs_thread[me] = realloc(gs_thread[me], gs_thread_alloc[me]*sizeof(int));
     if (gs_thread[me]==NULL)
-      STOP(_("Failed to realloc thread private group size buffer to %d*4bytes"), (int)gs_thread_alloc[me]);
+      STOP(_("Failed to realloc thread private group size buffer to %d*4bytes"), (int)gs_thread_alloc[me]);  // # nocov
   }
   memcpy(gs_thread[me]+gs_thread_n[me], x, n*sizeof(int));
   gs_thread_n[me] += n;
@@ -119,7 +119,7 @@ static void flush() {
     gs_alloc = (newn < nrow/3) ? (1+(newn*2)/4096)*4096 : nrow;
     gs = realloc(gs, gs_alloc*sizeof(int));
     if (gs==NULL)
-      STOP(_("Failed to realloc group size result to %d*4bytes"), (int)gs_alloc);
+      STOP(_("Failed to realloc group size result to %d*4bytes"), (int)gs_alloc); // # nocov
   }
   memcpy(gs+gs_n, gs_thread[me], n*sizeof(int));
   gs_n += n;
@@ -263,7 +263,7 @@ static void cradix_r(SEXP *xsub, int n, int radix)
     return;
   }
   if (thiscounts[0] != 0)
-    STOP(_("Logical error. counts[0]=%d in cradix but should have been decremented to 0. radix=%d"), thiscounts[0], radix);
+    STOP(_("Internal error. counts[0]=%d in cradix but should have been decremented to 0. radix=%d"), thiscounts[0], radix); // # nocov
   itmp = 0;
   for (int i=1; i<256; i++) {
     if (thiscounts[i] == 0) continue;
@@ -279,10 +279,10 @@ static void cradix(SEXP *x, int n)
 {
   cradix_counts = (int *)calloc(ustr_maxlen*256, sizeof(int));  // counts for the letters of left-aligned strings
   if (!cradix_counts)
-    STOP(_("Failed to alloc cradix_counts"));
+    STOP(_("Failed to alloc cradix_counts")); // # nocov
   cradix_xtmp = (SEXP *)malloc(ustr_n*sizeof(SEXP));
   if (!cradix_xtmp)
-    STOP(_("Failed to alloc cradix_tmp"));
+    STOP(_("Failed to alloc cradix_tmp")); // # nocov
   cradix_r(x, n, 0);
   free(cradix_counts); cradix_counts=NULL;
   free(cradix_xtmp);   cradix_xtmp=NULL;
@@ -385,9 +385,9 @@ SEXP setNumericRounding(SEXP droundArg)
 // init.c has initial call with default of 2
 {
   if (!isInteger(droundArg) || LENGTH(droundArg)!=1)
-    error(_("Must an integer or numeric vector length 1"));
+    error(_("Rounding level must be a length-1 integer or numeric vector"));
   if (INTEGER(droundArg)[0] < 0 || INTEGER(droundArg)[0] > 2)
-    error(_("Must be 2, 1 or 0"));
+    error(_("Rounding level must be 2, 1 or 0"));
   dround = INTEGER(droundArg)[0];
   dmask = dround ? 1 << (8*dround-1) : 0;
   return R_NilValue;
@@ -738,13 +738,13 @@ SEXP forder(SEXP DT, SEXP by, SEXP retGrpArg, SEXP sortGroupsArg, SEXP ascArg, S
   TMP =  (int *)malloc(nth*UINT16_MAX*sizeof(int)); // used by counting sort (my_n<=65536) in radix_r()
   UGRP = (uint8_t *)malloc(nth*256);                // TODO: align TMP and UGRP to cache lines (and do the same for stack allocations too)
   if (!TMP || !UGRP /*|| TMP%64 || UGRP%64*/)
-    STOP(_("Failed to allocate TMP or UGRP or they weren't cache line aligned: nth=%d"), nth);
+    STOP(_("Failed to allocate TMP or UGRP or they weren't cache line aligned: nth=%d"), nth); // # nocov
   if (retgrp) {
     gs_thread = calloc(nth, sizeof(int *));     // thread private group size buffers
     gs_thread_alloc = calloc(nth, sizeof(int));
     gs_thread_n = calloc(nth, sizeof(int));
     if (!gs_thread || !gs_thread_alloc || !gs_thread_n)
-      STOP(_("Could not allocate (very tiny) group size thread buffers"));
+      STOP(_("Could not allocate (very tiny) group size thread buffers")); // # nocov
   }
   if (nradix) {
     radix_r(0, nrow-1, 0);  // top level recursive call: (from, to, radix)
@@ -1065,7 +1065,7 @@ void radix_r(const int from, const int to, const int radix) {
   uint8_t  *ugrps =  malloc(nBatch*256*sizeof(uint8_t));
   int      *ngrps =  calloc(nBatch    ,sizeof(int));
   if (!counts || !ugrps || !ngrps)
-    STOP(_("Failed to allocate parallel counts. my_n=%d, nBatch=%d"), my_n, nBatch);
+    STOP(_("Failed to allocate parallel counts. my_n=%d, nBatch=%d"), my_n, nBatch); // # nocov
 
   bool skip=true;
   const int n_rem = nradix-radix-1;   // how many radix are remaining after this one
@@ -1175,7 +1175,7 @@ void radix_r(const int from, const int to, const int radix) {
   if (!skip) {
     int *TMP = malloc(my_n * sizeof(int));
     if (!TMP)
-      STOP(_("Unable to allocate TMP for my_n=%d items in parallel batch counting"), my_n);
+      STOP(_("Unable to allocate TMP for my_n=%d items in parallel batch counting"), my_n); // # nocov
     #pragma omp parallel for num_threads(getDTthreads())
     for (int batch=0; batch<nBatch; batch++) {
       const int *restrict      my_starts = starts + batch*256;
diff --git a/src/fread.c b/src/fread.c
index 530222366c..85130c0b4b 100644
--- a/src/fread.c
+++ b/src/fread.c
@@ -434,7 +434,7 @@ void copyFile(size_t fileSize, const char *msg, bool verbose)  // only called in
   double tt = wallclock();
   mmp_copy = (char *)malloc((size_t)fileSize + 1/* extra \0 */);
   if (!mmp_copy)
-    STOP(_("Unable to allocate %s of contiguous virtual RAM. %s allocation."), filesize_to_str(fileSize), msg);
+    STOP(_("Unable to allocate %s of contiguous virtual RAM. %s allocation."), filesize_to_str(fileSize), msg); // # nocov
   memcpy(mmp_copy, mmp, fileSize);
   sof = mmp_copy;
   eof = (char *)mmp_copy + fileSize;
@@ -1180,8 +1180,9 @@ int freadMain(freadMainArgs _args) {
   quote = args.quote;
   if (args.sep == quote && quote!='\0')
     STOP(_("sep == quote ('%c') is not allowed"), quote);
-  if (dec=='\0')
-    STOP(_("dec='' not allowed. Should be '.' or ','"));
+  if (dec != '.' && dec != ',') {
+    STOP(_("dec='%c' not allowed. Should be '.' or ','"), dec);
+  }
   if (args.sep == dec)
     STOP(_("sep == dec ('%c') is not allowed"), dec);
   if (quote == dec)
@@ -1666,7 +1667,7 @@ int freadMain(freadMainArgs _args) {
   type =    (int8_t *)malloc((size_t)ncol * sizeof(int8_t));
   tmpType = (int8_t *)malloc((size_t)ncol * sizeof(int8_t));  // used i) in sampling to not stop on errors when bad jump point and ii) when accepting user overrides
   if (!type || !tmpType)
-    STOP(_("Failed to allocate 2 x %d bytes for type and tmpType: %s"), ncol, strerror(errno));
+    STOP(_("Failed to allocate 2 x %d bytes for type and tmpType: %s"), ncol, strerror(errno)); // # nocov
 
   int8_t type0 = 1;
   while (disabled_parsers[type0]) type0++;
@@ -1894,7 +1895,7 @@ int freadMain(freadMainArgs _args) {
   } else {
     colNames = (lenOff*) calloc((size_t)ncol, sizeof(lenOff));
     if (!colNames)
-      STOP(_("Unable to allocate %d*%d bytes for column name pointers: %s"), ncol, sizeof(lenOff), strerror(errno));
+      STOP(_("Unable to allocate %d*%d bytes for column name pointers: %s"), ncol, sizeof(lenOff), strerror(errno)); // # nocov
     if (sep==' ') while (*ch==' ') ch++;
     void *targets[9] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, colNames + autoFirstColName};
     FieldParseContext fctx = {
@@ -2034,7 +2035,7 @@ int freadMain(freadMainArgs _args) {
   if (initialBuffRows < 10) initialBuffRows = 10;
 
   if (initialBuffRows > INT32_MAX)
-    STOP(_("Buffer size %"PRId64" is too large\n"), (int64_t)initialBuffRows);
+    STOP(_("Buffer size %"PRId64" is too large\n"), (int64_t)initialBuffRows); // # nocov
   nth = imin(nJumps, nth);
 
   if (verbose) DTPRINT(_("[11] Read the data\n"));
diff --git a/src/fwriteR.c b/src/fwriteR.c
index 2d15f53d6b..f3616b8120 100644
--- a/src/fwriteR.c
+++ b/src/fwriteR.c
@@ -39,7 +39,7 @@ int getMaxStringLen(const SEXP *col, const int64_t n) {
 int getMaxCategLen(SEXP col) {
   col = getAttrib(col, R_LevelsSymbol);
   if (!isString(col))
-    error(_("Internal error: col passed to getMaxCategLen is missing levels"));
+    error(_("Internal error: col passed to getMaxCategLen is missing levels")); // # nocov
   return getMaxStringLen( STRING_PTR(col), LENGTH(col) );
 }
 
@@ -170,7 +170,7 @@ SEXP fwriteR(
   )
 {
   if (!isNewList(DF))
-    error(_("fwrite must be passed an object of type list; e.g. data.frame, data.table"));
+    error(_("Internal error: fwrite received non-list input; this should have been caught earlier.")); // # nocov
   fwriteMainArgs args;
   args.is_gzip = LOGICAL(is_gzip_Arg)[0];
   args.bom = LOGICAL(bom_Arg)[0];
diff --git a/src/rbindlist.c b/src/rbindlist.c
index 0fb2690245..ad6611746b 100644
--- a/src/rbindlist.c
+++ b/src/rbindlist.c
@@ -10,7 +10,7 @@ SEXP rbindlist(SEXP l, SEXP usenamesArg, SEXP fillArg, SEXP idcolArg)
     error(_("use.names= should be TRUE, FALSE, or not used (\"check\" by default)"));  // R levels converts "check" to NA
   if (!length(l)) return(l);
   if (TYPEOF(l) != VECSXP)
-    error(_("Input to rbindlist must be a list. This list can contain data.tables, data.frames or plain lists."));
+    error(_("Internal error: input to rbindlist must be a list. Should have been caught earlier")); // # nocov
   Rboolean usenames = LOGICAL(usenamesArg)[0];
   const bool fill = LOGICAL(fillArg)[0];
   if (fill && usenames!=TRUE) {
@@ -44,7 +44,7 @@ SEXP rbindlist(SEXP l, SEXP usenamesArg, SEXP fillArg, SEXP idcolArg)
     }
     int nNames = length(getAttrib(li, R_NamesSymbol));
     if (nNames>0 && nNames!=thisncol)
-      error(_("Item %d has %d columns but %d column names. Invalid object."), i+1, thisncol, nNames);
+      error(_("Internal error: item %d has %d columns but %d column names. Invalid object."), i+1, thisncol, nNames); // # nocov
     if (nNames>0) anyNames=true;
     upperBoundUniqueNames += nNames;
     int maxLen=0, whichMax=0;
@@ -77,7 +77,7 @@ SEXP rbindlist(SEXP l, SEXP usenamesArg, SEXP fillArg, SEXP idcolArg)
     // first find number of unique column names present; i.e. length(unique(unlist(lapply(l,names))))
     SEXP *uniq = (SEXP *)malloc(upperBoundUniqueNames * sizeof(SEXP));  // upperBoundUniqueNames was initialized with 1 to ensure this is defined (otherwise 0 when no item has names)
     if (!uniq)
-      error(_("Failed to allocate upper bound of %"PRId64" unique column names [sum(lapply(l,ncol))]"), (int64_t)upperBoundUniqueNames);
+      error(_("Failed to allocate upper bound of %"PRId64" unique column names [sum(lapply(l,ncol))]"), (int64_t)upperBoundUniqueNames); // # nocov
     savetl_init();
     int nuniq=0;
     for (int i=0; i<LENGTH(l); i++) {
@@ -198,7 +198,7 @@ SEXP rbindlist(SEXP l, SEXP usenamesArg, SEXP fillArg, SEXP idcolArg)
   }
 
   if (fill && usenames==NA_LOGICAL)
-    error(_("Internal error: usenames==NA but fill=TRUE. usenames should have been set to TRUE earlier with warning."));
+    error(_("Internal error: usenames==NA but fill=TRUE. usenames should have been set to TRUE earlier with warning.")); // # nocov
   if (!fill && (usenames==TRUE || usenames==NA_LOGICAL)) {
     // Ensure no missings in both cases, and (when usenames==NA) all columns in same order too
     // We proceeded earlier as if fill was true, so varying ncol items will have missings here
@@ -214,7 +214,7 @@ SEXP rbindlist(SEXP l, SEXP usenamesArg, SEXP fillArg, SEXP idcolArg)
           int missi = i;
           while (colMap[i*ncol + j]==-1 && i<LENGTH(l)) i++;
           if (i==LENGTH(l))
-            error(_("Internal error: could not find the first column name not present in earlier item"));
+            error(_("Internal error: could not find the first column name not present in earlier item")); // # nocov
           SEXP s = getAttrib(VECTOR_ELT(l, i), R_NamesSymbol);
           int w2 = colMap[i*ncol + j];
           const char *str = isString(s) ? CHAR(STRING_ELT(s,w2)) : "";
@@ -228,7 +228,7 @@ SEXP rbindlist(SEXP l, SEXP usenamesArg, SEXP fillArg, SEXP idcolArg)
         if (w!=j && usenames==NA_LOGICAL) {
           SEXP s = getAttrib(VECTOR_ELT(l, i), R_NamesSymbol);
           if (!isString(s) || i==0)
-            error(_("Internal error: usenames==NA but an out-of-order name has been found in an item with no names or the first item. [%d]"), i);
+            error(_("Internal error: usenames==NA but an out-of-order name has been found in an item with no names or the first item. [%d]"), i); // # nocov
           snprintf(buff, 1000, _("Column %d ['%s'] of item %d appears in position %d in item %d. Set use.names=TRUE to match by column name, or use.names=FALSE to ignore column names.%s"),
                                w+1, CHAR(STRING_ELT(s,w)), i+1, j+1, i, extra);
           i = LENGTH(l);
@@ -376,10 +376,10 @@ SEXP rbindlist(SEXP l, SEXP usenamesArg, SEXP fillArg, SEXP idcolArg)
         const SEXP *sd = STRING_PTR(longestLevels);
         nLevel = allocLevel = longestLen;
         levelsRaw = (SEXP *)malloc(nLevel * sizeof(SEXP));
-        if (!levelsRaw) {
+        if (!levelsRaw) { // # nocov start
           savetl_end();
           error(_("Failed to allocate working memory for %d ordered factor levels of result column %d"), nLevel, idcol+j+1);
-        }
+        } // # nocov end
         for (int k=0; k<longestLen; ++k) {
           SEXP s = sd[k];
           if (TRUELENGTH(s)>0) savetl(s);

From 914b74997773907ddc0b7cdb2dfca3698ffa7e38 Mon Sep 17 00:00:00 2001
From: Michael Chirico <michael.chirico@grabtaxi.com>
Date: Sat, 14 Mar 2020 19:36:54 +0800
Subject: [PATCH 10/23] fix some tests, typos

---
 inst/tests/tests.Rraw | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/inst/tests/tests.Rraw b/inst/tests/tests.Rraw
index 0de19bf701..4447e55bae 100644
--- a/inst/tests/tests.Rraw
+++ b/inst/tests/tests.Rraw
@@ -6312,15 +6312,13 @@ options(datatable.optimize = Inf)
 
 # fread dec=',' e.g. France
 test(1439, fread("A;B\n1;2,34\n", dec="12"), error="nchar(dec) == 1L is not TRUE")
-test(1440, fread("A;B\n8;2,34\n", dec="1"), data.table(A=8L, B="2,34"))
 test(1441, fread("A;B\n8;2,34\n", dec=","), data.table(A=8L, B=2.34))
 test(1442, fread("A;B\n1;2,34\n", sep=".", dec="."), error="sep == dec ('.') is not allowed")
 test(1443, fread("A;B\n1;2,34\n", dec=",", sep=","), error="sep == dec (',') is not allowed")
 
 # sep=".", issue #502
 input = paste( paste("192.168.4.", 1:10, sep=""), collapse="\n")
-test(1444.1, fread(input, sep=".", dec="*"), ans<-data.table(V1=192L,V2=168L,V3=4L,V4=1:10))
-test(1444.2, fread(input, sep=".", dec=","), ans)
+test(1444.2, fread(input, sep=".", dec=","), ans<-data.table(V1=192L,V2=168L,V3=4L,V4=1:10))
 test(1444.3, fread(paste(paste("192. 168. 4. ", 1:10, sep = ""), collapse="\n"), sep=".", dec=","), ans)
 test(1444.4, fread(paste(paste("Hz.BB.GHG.", 1:10, sep = ""), collapse="\n"), sep=".", dec=","),
              data.table(V1="Hz",V2="BB",V3="GHG",V4=1:10))
@@ -16860,7 +16858,7 @@ test(2139.07, set(1L, NULL, 1L, 1L), error="object passed to assign isn't type V
 names(DT) = NULL
 test(2139.08, set(DT, NULL, 1L, 2L), error="data.table passed to assign has no names")
 test(2139.09, alloc.col(NULL), error="object passed to alloccol is NULL")
-test(2139.10, alloc.col(1L), error="object passed to allocco isn't type VECSXP")
+test(2139.10, alloc.col(1L), error="object passed to alloccol isn't type VECSXP")
 test(2139.11, set(NULL, NULL, 1L, 1L), error="object passed to assign is NULL")
 setDF(DT)
 names(DT) = 'V1'

From b3502bcb1544312a81d89bea8db87fcddf609979 Mon Sep 17 00:00:00 2001
From: Michael Chirico <michael.chirico@grabtaxi.com>
Date: Sat, 14 Mar 2020 19:58:36 +0800
Subject: [PATCH 11/23] more tests & nocov

---
 inst/tests/tests.Rraw | 10 ++++++++--
 src/dogroups.c        |  4 ++--
 src/freadR.c          |  4 ++--
 src/fsort.c           |  2 +-
 src/gsumm.c           | 10 +++++-----
 src/reorder.c         |  2 +-
 src/subset.c          |  2 +-
 7 files changed, 20 insertions(+), 14 deletions(-)

diff --git a/inst/tests/tests.Rraw b/inst/tests/tests.Rraw
index 4447e55bae..c1cad7289b 100644
--- a/inst/tests/tests.Rraw
+++ b/inst/tests/tests.Rraw
@@ -16871,6 +16871,12 @@ txt = 'a,b\n1,2'
 test(2139.14, fread(txt, sep=',', quote=','), error="sep == quote (',') is not allowed")
 test(2139.15, fread(txt, dec='&'), error="dec='&' not allowed")
 test(2139.16, fread(txt, quote='.', dec='.'), error="quote == dec ('.') is not allowed")
+test(2139.17, fread(txt, integer64=letters), error="'integer64' must be a single character string")
+test(2139.18, fread(txt, colClasses = list()), error="colClasses is type list but has no names")
 
-test(2139.17, setNumericRounding(1:2), error="Rounding level must be a length-1 integer or numeric vector")
-test(2139.18, setNumericRounding(-1), error="Rounding level must be 2, 1 or 0")
+test(2139.19, setNumericRounding(1:2), error="Rounding level must be a length-1 integer or numeric vector")
+test(2139.20, setNumericRounding(-1), error="Rounding level must be 2, 1 or 0")
+
+DT = data.table(1L)
+names(DT) = NULL
+test(2139.21, setcolorder(DT, 1L), error="data.table passed to setcolorder has no names")
\ No newline at end of file
diff --git a/src/dogroups.c b/src/dogroups.c
index 1cee6da79c..130fcdd473 100644
--- a/src/dogroups.c
+++ b/src/dogroups.c
@@ -68,10 +68,10 @@ SEXP dogroups(SEXP dt, SEXP dtcols, SEXP groups, SEXP grpcols, SEXP jiscols, SEX
   // non data.table aware package that uses rownames
   for (s = ATTRIB(SD); s != R_NilValue && TAG(s)!=R_RowNamesSymbol; s = CDR(s));  // getAttrib0 basically but that's hidden in attrib.c
   if (s==R_NilValue)
-    error(_("row.names attribute of .SD not found"));
+    error(_("Internal error: row.names attribute of .SD not found")); // # nocov
   rownames = CAR(s);
   if (!isInteger(rownames) || LENGTH(rownames)!=2 || INTEGER(rownames)[0]!=NA_INTEGER)
-    error(_("row.names of .SD isn't integer length 2 with NA as first item; i.e., .set_row_names(). [%s %d %d]"),type2char(TYPEOF(rownames)),LENGTH(rownames),INTEGER(rownames)[0]);
+    error(_("Internal error: row.names of .SD isn't integer length 2 with NA as first item; i.e., .set_row_names(). [%s %d %d]"), type2char(TYPEOF(rownames)), LENGTH(rownames), INTEGER(rownames)[0]); // # nocov
 
   // fetch names of .SD and prepare symbols. In case they are copied-on-write by user assigning to those variables
   // using <- in j (which is valid, useful and tested), they are repointed to the .SD cols for each group.
diff --git a/src/freadR.c b/src/freadR.c
index 392bcae651..d8a15677a0 100644
--- a/src/freadR.c
+++ b/src/freadR.c
@@ -332,10 +332,10 @@ bool userOverride(int8_t *type, lenOff *colNames, const char *anchor, const int
         }
       } else { // selectColClasses==true
         if (!selectInts)
-          STOP(_("Internal error: selectInts is NULL but selectColClasses is true"));
+          STOP(_("Internal error: selectInts is NULL but selectColClasses is true")); // # nocov
         const int n = length(colClassesSxp);
         if (length(selectSxp)!=n)
-          STOP(_("Internal error: length(selectSxp)!=length(colClassesSxp) but selectColClasses is true"));
+          STOP(_("Internal error: length(selectSxp)!=length(colClassesSxp) but selectColClasses is true")); // # nocov
         for (int i=0; i<n; ++i) {
           SEXP tt = STRING_ELT(colClassesSxp,i);
           if (tt==NA_STRING || tt==R_BlankString) continue;
diff --git a/src/fsort.c b/src/fsort.c
index 590431f4ed..4443576661 100644
--- a/src/fsort.c
+++ b/src/fsort.c
@@ -173,7 +173,7 @@ SEXP fsort(SEXP x, SEXP verboseArg) {
 
   R_xlen_t *counts = calloc(nBatch*MSBsize, sizeof(R_xlen_t));
   if (counts==NULL)
-    error(_("Unable to allocate working memory"));
+    error(_("Unable to allocate working memory")); // # nocov
   // provided MSBsize>=9, each batch is a multiple of at least one 4k page, so no page overlap
   // TODO: change all calloc, malloc and free to Calloc and Free to be robust to error() and catch ooms.
 
diff --git a/src/gsumm.c b/src/gsumm.c
index 8500b5061b..87ce66ba6e 100644
--- a/src/gsumm.c
+++ b/src/gsumm.c
@@ -121,7 +121,7 @@ SEXP gforce(SEXP env, SEXP jsub, SEXP o, SEXP f, SEXP l, SEXP irowsArg) {
     int *counts = calloc(nBatch*highSize, sizeof(int));  // TODO: cache-line align and make highSize a multiple of 64
     int *TMP   = malloc(nrow*2*sizeof(int));
     if (!counts || !TMP )
-      error(_("Internal error: Failed to allocate counts or TMP when assigning g in gforce"));
+      error(_("Internal error: Failed to allocate counts or TMP when assigning g in gforce")); // # nocov
     #pragma omp parallel for num_threads(getDTthreads())   // schedule(dynamic,1)
     for (int b=0; b<nBatch; b++) {
       const int howMany = b==nBatch-1 ? lastBatchSize : batchSize;
@@ -623,11 +623,11 @@ SEXP gmean(SEXP x, SEXP narm)
 
   long double *s = calloc(ngrp, sizeof(long double)), *si=NULL;  // s = sum; si = sum imaginary just for complex
   if (!s)
-    error(_("Unable to allocate %d * %d bytes for sum in gmean na.rm=TRUE"), ngrp, sizeof(long double));
+    error(_("Unable to allocate %d * %d bytes for sum in gmean na.rm=TRUE"), ngrp, sizeof(long double)); // # nocov
 
   int *c = calloc(ngrp, sizeof(int));
   if (!c)
-    error(_("Unable to allocate %d * %d bytes for counts in gmean na.rm=TRUE"), ngrp, sizeof(int));
+    error(_("Unable to allocate %d * %d bytes for counts in gmean na.rm=TRUE"), ngrp, sizeof(int)); // # nocov
 
   switch(TYPEOF(x)) {
   case LGLSXP: case INTSXP: {
@@ -654,7 +654,7 @@ SEXP gmean(SEXP x, SEXP narm)
     const Rcomplex *xd = COMPLEX(x);
     si = calloc(ngrp, sizeof(long double));
     if (!si)
-      error(_("Unable to allocate %d * %d bytes for si in gmean na.rm=TRUE"), ngrp, sizeof(long double));
+      error(_("Unable to allocate %d * %d bytes for si in gmean na.rm=TRUE"), ngrp, sizeof(long double)); // # nocov
     for (int i=0; i<n; i++) {
       int thisgrp = grp[i];
       int ix = (irowslen == -1) ? i : irows[i]-1;
@@ -1454,7 +1454,7 @@ SEXP gprod(SEXP x, SEXP narm)
     error(_("nrow [%d] != length(x) [%d] in %s"), nrow, n, "gprod");
   long double *s = malloc(ngrp * sizeof(long double));
   if (!s)
-    error(_("Unable to allocate %d * %d bytes for gprod"), ngrp, sizeof(long double));
+    error(_("Unable to allocate %d * %d bytes for gprod"), ngrp, sizeof(long double)); // # nocov
   for (i=0; i<ngrp; i++) s[i] = 1.0;
   ans = PROTECT(allocVector(REALSXP, ngrp));
   switch(TYPEOF(x)) {
diff --git a/src/reorder.c b/src/reorder.c
index d9d0766ea1..0c83a0ecae 100644
--- a/src/reorder.c
+++ b/src/reorder.c
@@ -106,7 +106,7 @@ SEXP setcolorder(SEXP x, SEXP o)
   SEXP names = getAttrib(x, R_NamesSymbol);
   const int ncol=LENGTH(x);
   if (isNull(names))
-    error(_("dt passed to setcolorder has no names"));
+    error(_("data.table passed to setcolorder has no names"));
   if (ncol != LENGTH(names))
     error(_("Internal error: dt passed to setcolorder has %d columns but %d names"), ncol, LENGTH(names));  // # nocov
   SEXP tt = PROTECT(allocVector(VECSXP, 2));
diff --git a/src/subset.c b/src/subset.c
index d43a742df3..39a6d18812 100644
--- a/src/subset.c
+++ b/src/subset.c
@@ -5,7 +5,7 @@ void subsetVectorRaw(SEXP ans, SEXP source, SEXP idx, const bool anyNA)
 {
   const int n = length(idx);
   if (length(ans)!=n)
-    error(_("Internal error: subsetVectorRaw length(ans)==%d n=%d"), length(ans), n);
+    error(_("Internal error: subsetVectorRaw length(ans)==%d n=%d"), length(ans), n); // # nocov
 
   const int *restrict idxp = INTEGER(idx);
   // anyNA refers to NA _in idx_; if there's NA in the data (source) that's just regular data to be copied

From c055e4345cc5055684f3dd4060b243423843bcd2 Mon Sep 17 00:00:00 2001
From: Michael Chirico <michael.chirico@grabtaxi.com>
Date: Sun, 15 Mar 2020 10:40:15 +0800
Subject: [PATCH 12/23] more tests

---
 inst/tests/tests.Rraw | 31 ++++++++++++++++++++++++++++++-
 src/gsumm.c           | 32 ++++++++++++++++----------------
 src/uniqlist.c        |  8 ++++----
 3 files changed, 50 insertions(+), 21 deletions(-)

diff --git a/inst/tests/tests.Rraw b/inst/tests/tests.Rraw
index c1cad7289b..a0bc101174 100644
--- a/inst/tests/tests.Rraw
+++ b/inst/tests/tests.Rraw
@@ -16879,4 +16879,33 @@ test(2139.20, setNumericRounding(-1), error="Rounding level must be 2, 1 or 0")
 
 DT = data.table(1L)
 names(DT) = NULL
-test(2139.21, setcolorder(DT, 1L), error="data.table passed to setcolorder has no names")
\ No newline at end of file
+test(2139.21, setcolorder(DT, 1L), error="data.table passed to setcolorder has no names")
+
+# uniqueNlogical
+test(2139.22, uniqueN(NA, na.rm=1), error="na.rm must be TRUE or FALSE")
+test(2139.23, rleid(1, 1:2), error="All elements of input list must be of same length")
+test(2139.24, uniqlengths(1L, 1:3), error="Input argument 'n' to 'uniqlengths' must be an integer vector of length 1")
+
+old = options(datatable.optimize = 2L)
+DT = data.table(a = 1:2, b = 1, f = factor(1), l = list(1))
+test(2139.25, DT[ , sum(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
+test(2139.26, DT[ , sum(f), by=a], error="sum is not meaningful for factors")
+test(2139.27, DT[ , mean(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
+test(2139.28, DT[ , mean(l), by=a], error="GForce can only be applied to columns, not .SD or similar")
+test(2139.29, DT[ , mean(f), by=a], error="mean is not meaningful for factors")
+test(2139.30, DT[ , min(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
+test(2139.31, DT[ , min(l), by=a], error="GForce min can only be applied to columns, not .SD or similar")
+test(2139.32, DT[ , min(f), by=a], error="min is not meaningful for factors")
+test(2139.33, DT[ , max(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
+test(2139.34, DT[ , max(l), by=a], error="GForce max can only be applied to columns, not .SD or similar")
+test(2139.35, DT[ , max(f), by=a], error="max is not meaningful for factors")
+test(2139.36, DT[ , median(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
+test(2139.37, DT[ , median(l), by=a], error="GForce median can only be applied to columns, not .SD or similar")
+test(2139.38, DT[ , median(f), by=a], error="max is not meaningful for factors")
+test(2139.39, DT[ , var(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
+test(2139.40, DT[ , var(l), by=a], error="GForce var/sd can only be applied to columns, not .SD or similar")
+test(2139.41, DT[ , var(f), by=a], error="var/sd is not meaningful for factors")
+test(2139.42, DT[ , prod(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
+test(2139.43, DT[ , prod(l), by=a], error="GForce prod can only be applied to columns, not .SD or similar")
+test(2139.44, DT[ , prod(f), by=a], error="prod is not meaningful for factors")
+options(old)
diff --git a/src/gsumm.c b/src/gsumm.c
index 87ce66ba6e..54b8db0b03 100644
--- a/src/gsumm.c
+++ b/src/gsumm.c
@@ -41,14 +41,14 @@ SEXP gforce(SEXP env, SEXP jsub, SEXP o, SEXP f, SEXP l, SEXP irowsArg) {
   double started = wallclock();
   const bool verbose = GetVerbose();
   if (TYPEOF(env) != ENVSXP)
-    error(_("env is not an environment"));
+    error(_("Internal error: env is not an environment")); // # nocov
   // The type of jsub is pretty flexbile in R, so leave checking to eval() below.
   if (!isInteger(o))
-    error(_("%s is not an integer vector"), "o");
+    error(_("%s is not an integer vector"), "o"); // # nocov
   if (!isInteger(f))
-    error(_("%s is not an integer vector"), "f");
+    error(_("%s is not an integer vector"), "f"); // # nocov
   if (!isInteger(l))
-    error(_("%s is not an integer vector"), "l");
+    error(_("%s is not an integer vector"), "l"); // # nocov
   if (isNull(irowsArg)) {
     irows = NULL;
     irowslen = -1;
@@ -60,7 +60,7 @@ SEXP gforce(SEXP env, SEXP jsub, SEXP o, SEXP f, SEXP l, SEXP irowsArg) {
   else error(_("irowsArg is neither an integer vector nor NULL"));  // # nocov
   ngrp = LENGTH(l);
   if (LENGTH(f) != ngrp)
-    error(_("length(f)=%d != length(l)=%d"), LENGTH(f), ngrp);
+    error(_("Internal error: length(f)=%d != length(l)=%d"), LENGTH(f), ngrp); // # nocov
   nrow=0;
   grpsize = INTEGER(l);
   maxgrpn = 0;
@@ -69,7 +69,7 @@ SEXP gforce(SEXP env, SEXP jsub, SEXP o, SEXP f, SEXP l, SEXP irowsArg) {
     if (grpsize[i]>maxgrpn) maxgrpn = grpsize[i];  // old comment to be checked: 'needed for #2046 and #2111 when maxgrpn attribute is not attached to empty o'
   }
   if (LENGTH(o) && LENGTH(o)!=nrow)
-    error(_("o has length %d but sum(l)=%d"), LENGTH(o), nrow);
+    error(_("Internal error: o has length %d but sum(l)=%d"), LENGTH(o), nrow); // # nocov
   {
     SEXP tt = getAttrib(o, install("maxgrpn"));
     if (length(tt)==1 && INTEGER(tt)[0]!=maxgrpn)
@@ -358,7 +358,7 @@ SEXP gsum(SEXP x, SEXP narmArg, SEXP warnOverflowArg)
   const bool verbose=GetVerbose();
   if (verbose) Rprintf(_("This gsum took (narm=%s) ... "), narm?"TRUE":"FALSE");
   if (nrow != n)
-    error(_("nrow [%d] != length(x) [%d] in %s"), nrow, n, "gsum");
+    error(_("Internal error: nrow [%d] != length(x) [%d] in %s"), nrow, n, "gsum"); // # nocov
   bool anyNA=false;
   SEXP ans;
   switch(TYPEOF(x)) {
@@ -619,7 +619,7 @@ SEXP gmean(SEXP x, SEXP narm)
   // na.rm=TRUE.  Similar to gsum, but we need to count the non-NA as well for the divisor
   const int n = (irowslen == -1) ? length(x) : irowslen;
   if (nrow != n)
-    error(_("nrow [%d] != length(x) [%d] in %s"), nrow, n, "gsum");
+    error(_("Internal error: nrow [%d] != length(x) [%d] in %s"), nrow, n, "gsum"); // # nocov
 
   long double *s = calloc(ngrp, sizeof(long double)), *si=NULL;  // s = sum; si = sum imaginary just for complex
   if (!s)
@@ -713,7 +713,7 @@ SEXP gmin(SEXP x, SEXP narm)
   //clock_t start = clock();
   SEXP ans;
   if (nrow != n)
-    error(_("nrow [%d] != length(x) [%d] in %s"), nrow, n, "gmin");
+    error(_("Internal error: nrow [%d] != length(x) [%d] in %s"), nrow, n, "gmin"); // # nocov
   int protecti=0;
   switch(TYPEOF(x)) {
   case LGLSXP: case INTSXP:
@@ -836,7 +836,7 @@ SEXP gmax(SEXP x, SEXP narm)
   //clock_t start = clock();
   SEXP ans;
   if (nrow != n)
-    error(_("nrow [%d] != length(x) [%d] in %s"), nrow, n, "gmax");
+    error(_("Internal error: nrow [%d] != length(x) [%d] in %s"), nrow, n, "gmax"); // # nocov
 
   // TODO rework gmax in the same way as gmin and remove this *update
   char *update = (char *)R_alloc(ngrp, sizeof(char));
@@ -983,7 +983,7 @@ SEXP gmedian(SEXP x, SEXP narmArg) {
   const bool isInt64 = INHERITS(x, char_integer64), narm = LOGICAL(narmArg)[0];
   int n = (irowslen == -1) ? length(x) : irowslen;
   if (nrow != n)
-    error(_("nrow [%d] != length(x) [%d] in %s"), nrow, n, "gmedian");
+    error(_("Internal error: nrow [%d] != length(x) [%d] in %s"), nrow, n, "gmedian"); // # nocov
   SEXP ans = PROTECT(allocVector(REALSXP, ngrp));
   double *ansd = REAL(ans);
   switch(TYPEOF(x)) {
@@ -1034,7 +1034,7 @@ SEXP glast(SEXP x) {
   int n = (irowslen == -1) ? length(x) : irowslen;
   SEXP ans;
   if (nrow != n)
-    error(_("nrow [%d] != length(x) [%d] in %s"), nrow, n, "gtail");
+    error(_("Internal error: nrow [%d] != length(x) [%d] in %s"), nrow, n, "gtail"); // # nocov
   switch(TYPEOF(x)) {
   case LGLSXP: {
     const int *ix = LOGICAL(x);
@@ -1115,7 +1115,7 @@ SEXP gfirst(SEXP x) {
   int n = (irowslen == -1) ? length(x) : irowslen;
   SEXP ans;
   if (nrow != n)
-    error(_("nrow [%d] != length(x) [%d] in %s"), nrow, n, "ghead");
+    error(_("Internal error: nrow [%d] != length(x) [%d] in %s"), nrow, n, "ghead"); // # nocov
   switch(TYPEOF(x)) {
   case LGLSXP: {
     int const *ix = LOGICAL(x);
@@ -1210,7 +1210,7 @@ SEXP gnthvalue(SEXP x, SEXP valArg) {
   int n = (irowslen == -1) ? length(x) : irowslen;
   SEXP ans;
   if (nrow != n)
-    error(_("nrow [%d] != length(x) [%d] in %s"), nrow, n, "ghead");
+    error(_("Internal error: nrow [%d] != length(x) [%d] in %s"), nrow, n, "ghead"); // # nocov
   switch(TYPEOF(x)) {
   case LGLSXP: {
     const int *ix = LOGICAL(x);
@@ -1304,7 +1304,7 @@ SEXP gvarsd1(SEXP x, SEXP narm, Rboolean isSD)
   long double m, s, v;
   R_len_t i, j, ix, thisgrpsize = 0, n = (irowslen == -1) ? length(x) : irowslen;
   if (nrow != n)
-    error(_("nrow [%d] != length(x) [%d] in %s"), nrow, n, "gvar");
+    error(_("Internal error: nrow [%d] != length(x) [%d] in %s"), nrow, n, "gvar"); // # nocov
   SEXP sub, ans = PROTECT(allocVector(REALSXP, ngrp));
   Rboolean ans_na;
   switch(TYPEOF(x)) {
@@ -1451,7 +1451,7 @@ SEXP gprod(SEXP x, SEXP narm)
   //clock_t start = clock();
   SEXP ans;
   if (nrow != n)
-    error(_("nrow [%d] != length(x) [%d] in %s"), nrow, n, "gprod");
+    error(_("Internal error: nrow [%d] != length(x) [%d] in %s"), nrow, n, "gprod"); // # nocov
   long double *s = malloc(ngrp * sizeof(long double));
   if (!s)
     error(_("Unable to allocate %d * %d bytes for gprod"), ngrp, sizeof(long double)); // # nocov
diff --git a/src/uniqlist.c b/src/uniqlist.c
index 8f51bd61e2..9b85f42f76 100644
--- a/src/uniqlist.c
+++ b/src/uniqlist.c
@@ -150,7 +150,7 @@ SEXP uniqlist(SEXP l, SEXP order)
 SEXP uniqlengths(SEXP x, SEXP n) {
   // seems very similar to rbindlist.c:uniq_lengths. TODO: centralize into common function
   if (TYPEOF(x) != INTSXP)
-    error(_("Input argument 'x' to 'uniqlengths' must be an integer vector"));
+    error(_("Internal error: argument 'x' to 'uniqlengths' must be an integer vector")); // # nocov
   if (TYPEOF(n) != INTSXP || length(n) != 1)
     error(_("Input argument 'n' to 'uniqlengths' must be an integer vector of length 1"));
   R_len_t len = length(x);
@@ -171,12 +171,12 @@ SEXP rleid(SEXP l, SEXP cols) {
   R_len_t ncol = length(l), lencols = length(cols);
   if (!nrow || !ncol) return(allocVector(INTSXP, 0));
   if (!isInteger(cols) || lencols==0)
-    error(_("cols must be an integer vector with length >= 1"));
+    error(_("Internal error: cols must be an integer vector with length >= 1")); // # nocov
   int *icols = INTEGER(cols);
   for (int i=0; i<lencols; i++) {
     int elem = icols[i];
     if (elem<1 || elem>ncol)
-      error(_("Item %d of cols is %d which is outside range of l [1,length(l)=%d]"), i+1, elem, ncol);
+      error(_("Internal error: Item %d of cols is %d which is outside range of l [1,length(l)=%d]"), i+1, elem, ncol); // # nocov
   }
   for (int i=1; i<ncol; i++) {
     if (xlength(VECTOR_ELT(l,i)) != nrow)
@@ -359,7 +359,7 @@ SEXP nestedid(SEXP l, SEXP cols, SEXP order, SEXP grps, SEXP resetvals, SEXP mul
 SEXP uniqueNlogical(SEXP x, SEXP narmArg) {
   // single pass; short-circuit and return as soon as all 3 values are found
   if (!isLogical(x))
-    error(_("x is not a logical vector"));
+    error(_("Internal error: x is not a logical vector")); // # nocov
   if (!isLogical(narmArg) || length(narmArg)!=1 || INTEGER(narmArg)[0]==NA_INTEGER)
     error(_("na.rm must be TRUE or FALSE"));
   bool narm = LOGICAL(narmArg)[0]==1;

From e1b15501b918cf55c3e623ccb14e78e406b48320 Mon Sep 17 00:00:00 2001
From: Michael Chirico <michael.chirico@grabtaxi.com>
Date: Sun, 15 Mar 2020 10:50:34 +0800
Subject: [PATCH 13/23] typos

---
 inst/tests/tests.Rraw | 4 ++--
 src/uniqlist.c        | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/inst/tests/tests.Rraw b/inst/tests/tests.Rraw
index a0bc101174..6fe5c9e29a 100644
--- a/inst/tests/tests.Rraw
+++ b/inst/tests/tests.Rraw
@@ -16891,7 +16891,7 @@ DT = data.table(a = 1:2, b = 1, f = factor(1), l = list(1))
 test(2139.25, DT[ , sum(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
 test(2139.26, DT[ , sum(f), by=a], error="sum is not meaningful for factors")
 test(2139.27, DT[ , mean(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
-test(2139.28, DT[ , mean(l), by=a], error="GForce can only be applied to columns, not .SD or similar")
+test(2139.28, DT[ , mean(l), by=a], error="GForce mean can only be applied to columns, not .SD or similar")
 test(2139.29, DT[ , mean(f), by=a], error="mean is not meaningful for factors")
 test(2139.30, DT[ , min(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
 test(2139.31, DT[ , min(l), by=a], error="GForce min can only be applied to columns, not .SD or similar")
@@ -16901,7 +16901,7 @@ test(2139.34, DT[ , max(l), by=a], error="GForce max can only be applied to colu
 test(2139.35, DT[ , max(f), by=a], error="max is not meaningful for factors")
 test(2139.36, DT[ , median(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
 test(2139.37, DT[ , median(l), by=a], error="GForce median can only be applied to columns, not .SD or similar")
-test(2139.38, DT[ , median(f), by=a], error="max is not meaningful for factors")
+test(2139.38, DT[ , median(f), by=a], error="median is not meaningful for factors")
 test(2139.39, DT[ , var(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
 test(2139.40, DT[ , var(l), by=a], error="GForce var/sd can only be applied to columns, not .SD or similar")
 test(2139.41, DT[ , var(f), by=a], error="var/sd is not meaningful for factors")
diff --git a/src/uniqlist.c b/src/uniqlist.c
index 9b85f42f76..d7c16a4ebd 100644
--- a/src/uniqlist.c
+++ b/src/uniqlist.c
@@ -180,7 +180,7 @@ SEXP rleid(SEXP l, SEXP cols) {
   }
   for (int i=1; i<ncol; i++) {
     if (xlength(VECTOR_ELT(l,i)) != nrow)
-      error(_("All elements to input list must be of same length. Element [%d] has length %"PRIu64" != length of first element = %"PRIu64"."), i+1, (uint64_t)xlength(VECTOR_ELT(l,i)), (uint64_t)nrow);
+      error(_("All elements of input list must be of same length. Element [%d] has length %"PRIu64" != length of first element = %"PRIu64"."), i+1, (uint64_t)xlength(VECTOR_ELT(l,i)), (uint64_t)nrow);
   }
   SEXP ans = PROTECT(allocVector(INTSXP, nrow));
   int *ians = INTEGER(ans);

From e8c41ea2829d35abf0c0dbf342f33171df0a5506 Mon Sep 17 00:00:00 2001
From: Michael Chirico <michael.chirico@grabtaxi.com>
Date: Sun, 15 Mar 2020 11:40:15 +0800
Subject: [PATCH 14/23] more tests, nocov

---
 inst/tests/tests.Rraw |  7 +++++++
 src/dogroups.c        | 16 ++++++++--------
 src/vecseq.c          |  2 +-
 src/wrappers.c        |  6 +++---
 4 files changed, 19 insertions(+), 12 deletions(-)

diff --git a/inst/tests/tests.Rraw b/inst/tests/tests.Rraw
index 6fe5c9e29a..c6a0b243a0 100644
--- a/inst/tests/tests.Rraw
+++ b/inst/tests/tests.Rraw
@@ -54,6 +54,7 @@ if (exists("test.data.table", .GlobalEnv, inherits=FALSE)) {
   test = data.table:::test
   uniqlengths = data.table:::uniqlengths
   uniqlist = data.table:::uniqlist
+  veqseq = data.table:::vecseq
   which_ = data.table:::which_
   which.first = data.table:::which.first
   which.last = data.table:::which.last
@@ -16909,3 +16910,9 @@ test(2139.42, DT[ , prod(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE"
 test(2139.43, DT[ , prod(l), by=a], error="GForce prod can only be applied to columns, not .SD or similar")
 test(2139.44, DT[ , prod(f), by=a], error="prod is not meaningful for factors")
 options(old)
+
+test(2139.45, vecseq(NA, NA, NA), error="x must be an integer vector")
+test(2139.46, vecseq(1L, NA, NA), error="len must be an integer vector")
+test(2139.47, vecseq(1L, 1:2, NA), error="x and len must be the same length")
+test(2139.48, vecseq(1L, 1L, 1L), error="clamp must be a double vector length 1")
+test(2139.49, vecseq(1L, 1L, -1), error="clamp must be positive")
diff --git a/src/dogroups.c b/src/dogroups.c
index 130fcdd473..c02296e091 100644
--- a/src/dogroups.c
+++ b/src/dogroups.c
@@ -24,7 +24,7 @@ SEXP dogroups(SEXP dt, SEXP dtcols, SEXP groups, SEXP grpcols, SEXP jiscols, SEX
   if (!isNull(xjiscols) && LENGTH(order) && !LOGICAL(on)[0])
     error(_("Internal error: xjiscols not NULL but o__ has length")); // # nocov
   if(!isEnvironment(env))
-    error(_("'env' should be an environment"));
+    error(_("Internal error: 'env' should be an environment")); // # nocov
   ngrp = length(starts);  // the number of groups  (nrow(groups) will be larger when by)
   ngrpcols = length(grpcols);
   nrowgroups = length(VECTOR_ELT(groups,0));
@@ -48,7 +48,7 @@ SEXP dogroups(SEXP dt, SEXP dtcols, SEXP groups, SEXP grpcols, SEXP jiscols, SEX
   setAttrib(BY, R_NamesSymbol, bynames); // Fix for #42 - BY doesn't retain names anymore
   R_LockBinding(sym_BY, env);
   if (isNull(jiscols) && (length(bynames)!=length(groups) || length(bynames)!=length(grpcols)))
-    error(_("!length(bynames)[%d]==length(groups)[%d]==length(grpcols)[%d]"),length(bynames),length(groups),length(grpcols));
+    error(_("Internal error: !length(bynames)[%d]==length(groups)[%d]==length(grpcols)[%d]"), length(bynames), length(groups), length(grpcols)); // # nocov
   // TO DO: check this check above.
 
   N =   PROTECT(findVar(install(".N"), env));   nprotect++; // PROTECT for rchk
@@ -77,7 +77,7 @@ SEXP dogroups(SEXP dt, SEXP dtcols, SEXP groups, SEXP grpcols, SEXP jiscols, SEX
   // using <- in j (which is valid, useful and tested), they are repointed to the .SD cols for each group.
   SEXP names = PROTECT(getAttrib(SDall, R_NamesSymbol)); nprotect++;
   if (length(names) != length(SDall))
-    error(_("length(names)!=length(SD)"));
+    error(_("Internal erro: length(names)!=length(.SD)")); // # nocov
   SEXP *nameSyms = (SEXP *)R_alloc(length(names), sizeof(SEXP));
   for(int i=0; i<length(SDall); ++i) {
     if (SIZEOF(VECTOR_ELT(SDall, i))==0)
@@ -92,7 +92,7 @@ SEXP dogroups(SEXP dt, SEXP dtcols, SEXP groups, SEXP grpcols, SEXP jiscols, SEX
 
   SEXP xknames = PROTECT(getAttrib(xSD, R_NamesSymbol)); nprotect++;
   if (length(xknames) != length(xSD))
-    error(_("length(xknames)!=length(xSD)"));
+    error(_("Internal error: length(xknames)!=length(xSD)")); // # nocov
   SEXP *xknameSyms = (SEXP *)R_alloc(length(xknames), sizeof(SEXP));
   for(int i=0; i<length(xSD); ++i) {
     if (SIZEOF(VECTOR_ELT(xSD, i))==0)
@@ -101,9 +101,9 @@ SEXP dogroups(SEXP dt, SEXP dtcols, SEXP groups, SEXP grpcols, SEXP jiscols, SEX
   }
 
   if (length(iSD)!=length(jiscols))
-    error(_("length(iSD)[%d] != length(jiscols)[%d]"),length(iSD),length(jiscols));
+    error(_("Internal error: length(iSD)[%d] != length(jiscols)[%d]"), length(iSD), length(jiscols)); // # nocov
   if (length(xSD)!=length(xjiscols))
-    error(_("length(xSD)[%d] != length(xjiscols)[%d]"),length(xSD),length(xjiscols));
+    error(_("Internal error: length(xSD)[%d] != length(xjiscols)[%d]"), length(xSD), length(xjiscols)); // # nocov
 
   SEXP listwrap = PROTECT(allocVector(VECSXP, 1)); nprotect++;
   Rboolean jexpIsSymbolOtherThanSD = (isSymbol(jexp) && strcmp(CHAR(PRINTNAME(jexp)),".SD")!=0);  // test 559
@@ -325,7 +325,7 @@ SEXP dogroups(SEXP dt, SEXP dtcols, SEXP groups, SEXP grpcols, SEXP jiscols, SEX
         estn = ((double)ngrp/i)*1.1*(ansloc+maxn);
         if (verbose) Rprintf(_("dogroups: growing from %d to %d rows\n"), length(VECTOR_ELT(ans,0)), estn);
         if (length(ans) != ngrpcols + njval)
-          error(_("dogroups: length(ans)[%d]!=ngrpcols[%d]+njval[%d]"),length(ans),ngrpcols,njval);
+          error(_("Internal error in dogroups: length(ans)[%d]!=ngrpcols[%d]+njval[%d]"), length(ans), ngrpcols, njval); // # nocov
         for (int j=0; j<length(ans); ++j) SET_VECTOR_ELT(ans, j, growVector(VECTOR_ELT(ans,j), estn));
       }
     }
@@ -407,7 +407,7 @@ SEXP growVector(SEXP x, const R_len_t newlen)
   SEXP newx;
   R_len_t len = length(x);
   if (isNull(x))
-    error(_("growVector passed NULL"));
+    error(_("Internal error: growVector passed NULL")); // # nocov
   PROTECT(newx = allocVector(TYPEOF(x), newlen));   // TO DO: R_realloc(?) here?
   if (newlen < len) len=newlen;   // i.e. shrink
   switch (TYPEOF(x)) {
diff --git a/src/vecseq.c b/src/vecseq.c
index fccf0a225a..6c8948da3e 100644
--- a/src/vecseq.c
+++ b/src/vecseq.c
@@ -25,7 +25,7 @@ SEXP vecseq(SEXP x, SEXP len, SEXP clamp)
     reslen += ilen[i];
   }
   if (!isNull(clamp)) {
-    if (!isNumeric(clamp) || LENGTH(clamp)!=1)
+    if (TYPEOF(clamp) != REALSXP || LENGTH(clamp)!=1)
       error(_("clamp must be a double vector length 1"));
     double limit = REAL(clamp)[0];
     if (limit<0)
diff --git a/src/wrappers.c b/src/wrappers.c
index a470ff9e46..95e206634e 100644
--- a/src/wrappers.c
+++ b/src/wrappers.c
@@ -65,12 +65,12 @@ SEXP setlistelt(SEXP l, SEXP i, SEXP value)
   R_len_t i2;
   // Internal use only. So that := can update elements of a list of data.table, #2204. Just needed to overallocate/grow the VECSXP.
   if (!isNewList(l))
-    error(_("First argument to setlistelt must be a list()"));
+    error(_("Internal error: first argument to setlistelt must be a list()")); // # nocov
   if (!isInteger(i) || LENGTH(i)!=1)
-    error(_("Second argument to setlistelt must a length 1 integer vector"));
+    error(_("Internal error: second argument to setlistelt must a length 1 integer vector")); // # nocov
   i2 = INTEGER(i)[0];
   if (LENGTH(l) < i2 || i2<1)
-    error(_("i (%d) is outside the range of items [1,%d]"),i2,LENGTH(l));
+    error(_("Internal error: i (%d) is outside the range of items [1,%d]"), i2, LENGTH(l)); // # nocov
   SET_VECTOR_ELT(l, i2-1, value);
   return(R_NilValue);
 }

From 9183810c735a208caa9aa94fbbd0cf2edf337a0c Mon Sep 17 00:00:00 2001
From: Michael Chirico <michael.chirico@grabtaxi.com>
Date: Sun, 15 Mar 2020 14:30:38 +0800
Subject: [PATCH 15/23] not really reproducing the CI errors locally. managed
 to get two on --vanilla

---
 inst/tests/tests.Rraw | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/inst/tests/tests.Rraw b/inst/tests/tests.Rraw
index c6a0b243a0..794597d6c0 100644
--- a/inst/tests/tests.Rraw
+++ b/inst/tests/tests.Rraw
@@ -16914,5 +16914,5 @@ options(old)
 test(2139.45, vecseq(NA, NA, NA), error="x must be an integer vector")
 test(2139.46, vecseq(1L, NA, NA), error="len must be an integer vector")
 test(2139.47, vecseq(1L, 1:2, NA), error="x and len must be the same length")
-test(2139.48, vecseq(1L, 1L, 1L), error="clamp must be a double vector length 1")
+test(2139.48, vecseq(1L, 1L, 's'), error="clamp must be a double vector length 1")
 test(2139.49, vecseq(1L, 1L, -1), error="clamp must be positive")

From c524c567fbb4115b3083fe5f889629993a20d18d Mon Sep 17 00:00:00 2001
From: Michael Chirico <michael.chirico@grabtaxi.com>
Date: Sun, 15 Mar 2020 16:52:59 +0800
Subject: [PATCH 16/23] found the typo

---
 inst/tests/tests.Rraw | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/inst/tests/tests.Rraw b/inst/tests/tests.Rraw
index 794597d6c0..bd82db28a6 100644
--- a/inst/tests/tests.Rraw
+++ b/inst/tests/tests.Rraw
@@ -54,7 +54,7 @@ if (exists("test.data.table", .GlobalEnv, inherits=FALSE)) {
   test = data.table:::test
   uniqlengths = data.table:::uniqlengths
   uniqlist = data.table:::uniqlist
-  veqseq = data.table:::vecseq
+  vecseq = data.table:::vecseq
   which_ = data.table:::which_
   which.first = data.table:::which.first
   which.last = data.table:::which.last

From 75ba288e1f39043c65abf48641b19c099cd030de Mon Sep 17 00:00:00 2001
From: Michael Chirico <michael.chirico@grabtaxi.com>
Date: Sun, 15 Mar 2020 23:43:50 +0800
Subject: [PATCH 17/23] two more files

---
 inst/tests/tests.Rraw |  5 +++++
 src/fmelt.c           | 20 ++++++++++----------
 src/reorder.c         |  4 ++--
 3 files changed, 17 insertions(+), 12 deletions(-)

diff --git a/inst/tests/tests.Rraw b/inst/tests/tests.Rraw
index bd82db28a6..da3c041756 100644
--- a/inst/tests/tests.Rraw
+++ b/inst/tests/tests.Rraw
@@ -16916,3 +16916,8 @@ test(2139.46, vecseq(1L, NA, NA), error="len must be an integer vector")
 test(2139.47, vecseq(1L, 1:2, NA), error="x and len must be the same length")
 test(2139.48, vecseq(1L, 1L, 's'), error="clamp must be a double vector length 1")
 test(2139.49, vecseq(1L, 1L, -1), error="clamp must be positive")
+
+test(2139.50, which_(1L, FALSE), error="Argument to 'which' must be logical")
+
+test(2139.51, melt(data.table(1), variable.name=1), error="Argument 'variable.name' must be a character vector")
+test(2139.52, melt(data.table(1), value.name=1), error="Argument 'value.name' must be a character vector")
diff --git a/src/fmelt.c b/src/fmelt.c
index bdd23d35a2..c30225f718 100644
--- a/src/fmelt.c
+++ b/src/fmelt.c
@@ -16,7 +16,7 @@ SEXP seq_int(int n, int start) {
 // very specific "set_diff" for integers
 SEXP set_diff(SEXP x, int n) {
   if (TYPEOF(x) != INTSXP)
-    error(_("'x' must be an integer"));
+    error(_("Internal error: 'x' must be an integer")); // # nocov
   if (n <= 0)
     error(_("Internal error: n must be a positive integer in set_diff")); // # nocov
   SEXP table = PROTECT(seq_int(n, 1));       // TODO: using match to 1:n seems odd here, why use match at all
@@ -71,9 +71,9 @@ SEXP concat(SEXP vec, SEXP idx) {
   int nidx=length(idx);
 
   if (TYPEOF(vec) != STRSXP)
-    error(_("concat: 'vec must be a character vector"));
+    error(_("Internal error in concat: 'vec must be a character vector")); // # nocov
   if (!isInteger(idx) || length(idx) < 0)
-    error(_("concat: 'idx' must be an integer vector of length >= 0"));
+    error(_("Internal error in concat: 'idx' must be an integer vector of length >= 0")); // # nocov
   const int *iidx = INTEGER(idx);
   for (int i=0; i<length(idx); ++i) {
     if (iidx[i] < 0 || iidx[i] > length(vec))
@@ -681,7 +681,7 @@ SEXP getidcols(SEXP DT, SEXP dtnames, Rboolean verbose, struct processData *data
     }
       break;
     default :
-      error(_("Unknown column type '%s' for column '%s' in 'data'"), type2char(TYPEOF(thiscol)), CHAR(STRING_ELT(dtnames, INTEGER(data->idcols)[i]-1)));
+      error(_("Internal error: unknown column type '%s' for column '%s' in 'data'"), type2char(TYPEOF(thiscol)), CHAR(STRING_ELT(dtnames, INTEGER(data->idcols)[i]-1))); // # nocov
     }
   }
   UNPROTECT(1);
@@ -693,19 +693,19 @@ SEXP fmelt(SEXP DT, SEXP id, SEXP measure, SEXP varfactor, SEXP valfactor, SEXP
   Rboolean narm=FALSE, verbose=FALSE;
 
   if (!isNewList(DT))
-    error(_("Input is not of type VECSXP, expected a data.table, data.frame or list"));
+    error(_("Internal error: input is not of type VECSXP, expected a data.table, data.frame or list")); // # nocov
   if (!isLogical(valfactor))
-    error(_("Argument 'value.factor' should be logical TRUE/FALSE"));
+    error(_("Internal error: 'value.factor' should be logical TRUE/FALSE")); // # nocov
   if (!isLogical(varfactor))
-    error(_("Argument 'variable.factor' should be logical TRUE/FALSE"));
+    error(_("Internal error: 'variable.factor' should be logical TRUE/FALSE")); // # nocov
   if (!isLogical(narmArg))
-    error(_("Argument 'na.rm' should be logical TRUE/FALSE."));
+    error(_("Internal error: 'na.rm' should be logical TRUE/FALSE.")); // # nocov
   if (!isString(varnames))
     error(_("Argument 'variable.name' must be a character vector"));
   if (!isString(valnames))
     error(_("Argument 'value.name' must be a character vector"));
   if (!isLogical(verboseArg))
-    error(_("Argument 'verbose' should be logical TRUE/FALSE"));
+    error(_("Internal error: argument 'verbose' should be logical TRUE/FALSE")); // # nocov
   if (LOGICAL(verboseArg)[0] == TRUE) verbose = TRUE;
   int ncol = LENGTH(DT);
   if (!ncol) {
@@ -715,7 +715,7 @@ SEXP fmelt(SEXP DT, SEXP id, SEXP measure, SEXP varfactor, SEXP valfactor, SEXP
   int protecti=0;
   dtnames = PROTECT(getAttrib(DT, R_NamesSymbol)); protecti++;
   if (isNull(dtnames))
-    error(_("names(data) is NULL. Please report to data.table-help"));
+    error(_("Internal error: names(data) is NULL. Please report to data.table-help")); // # nocov
   if (LOGICAL(narmArg)[0] == TRUE) narm = TRUE;
   if (LOGICAL(verboseArg)[0] == TRUE) verbose = TRUE;
   struct processData data;
diff --git a/src/reorder.c b/src/reorder.c
index 0c83a0ecae..9da9c0c228 100644
--- a/src/reorder.c
+++ b/src/reorder.c
@@ -32,9 +32,9 @@ SEXP reorder(SEXP x, SEXP order)
     ncol = 1;
   }
   if (!isInteger(order))
-    error(_("order must be an integer vector"));
+    error(_("Internal error: order must be an integer vector")); // # nocov
   if (length(order) != nrow)
-    error(_("nrow(x)[%d]!=length(order)[%d]"),nrow,length(order));
+    error(_("Internal error: nrow(x)[%d]!=length(order)[%d]"), nrow, length(order)); // # nocov
   int nprotect = 0;
   if (ALTREP(order)) { order=PROTECT(copyAsPlain(order)); nprotect++; }  // TODO: if it's an ALTREP sequence some optimizations are possible rather than expand
 

From baeb76879bbff5ba6f990ff5bb15d5d1d645fa23 Mon Sep 17 00:00:00 2001
From: Michael Chirico <michael.chirico@grabtaxi.com>
Date: Mon, 16 Mar 2020 00:04:31 +0800
Subject: [PATCH 18/23] +tests

---
 inst/tests/tests.Rraw | 73 ++++++++++++++++++++++---------------------
 src/freadR.c          |  4 +--
 src/wrappers.c        |  2 +-
 3 files changed, 41 insertions(+), 38 deletions(-)

diff --git a/inst/tests/tests.Rraw b/inst/tests/tests.Rraw
index da3c041756..c7eb1e42e9 100644
--- a/inst/tests/tests.Rraw
+++ b/inst/tests/tests.Rraw
@@ -16873,51 +16873,54 @@ test(2139.14, fread(txt, sep=',', quote=','), error="sep == quote (',') is not a
 test(2139.15, fread(txt, dec='&'), error="dec='&' not allowed")
 test(2139.16, fread(txt, quote='.', dec='.'), error="quote == dec ('.') is not allowed")
 test(2139.17, fread(txt, integer64=letters), error="'integer64' must be a single character string")
-test(2139.18, fread(txt, colClasses = list()), error="colClasses is type list but has no names")
+test(2139.18, fread(txt, colClasses=list()), error="colClasses is type list but has no names")
+test(2139.19, fread(txt, select = c(1, 1)), error="Column number 1 ('a') has been selected twice by select=")
+test(2139.20, fread(txt, colClasses=as.raw(0)), error="colClasses is not type list or character vector")
+test(2139.21, fread(txt, colClasses=list()), error="colClasses is type list but has no names")
 
-test(2139.19, setNumericRounding(1:2), error="Rounding level must be a length-1 integer or numeric vector")
-test(2139.20, setNumericRounding(-1), error="Rounding level must be 2, 1 or 0")
+test(2139.20, setNumericRounding(1:2), error="Rounding level must be a length-1 integer or numeric vector")
+test(2139.21, setNumericRounding(-1), error="Rounding level must be 2, 1 or 0")
 
 DT = data.table(1L)
 names(DT) = NULL
-test(2139.21, setcolorder(DT, 1L), error="data.table passed to setcolorder has no names")
+test(2139.22, setcolorder(DT, 1L), error="data.table passed to setcolorder has no names")
 
 # uniqueNlogical
-test(2139.22, uniqueN(NA, na.rm=1), error="na.rm must be TRUE or FALSE")
-test(2139.23, rleid(1, 1:2), error="All elements of input list must be of same length")
-test(2139.24, uniqlengths(1L, 1:3), error="Input argument 'n' to 'uniqlengths' must be an integer vector of length 1")
+test(2139.23, uniqueN(NA, na.rm=1), error="na.rm must be TRUE or FALSE")
+test(2139.24, rleid(1, 1:2), error="All elements of input list must be of same length")
+test(2139.25, uniqlengths(1L, 1:3), error="Input argument 'n' to 'uniqlengths' must be an integer vector of length 1")
 
 old = options(datatable.optimize = 2L)
 DT = data.table(a = 1:2, b = 1, f = factor(1), l = list(1))
-test(2139.25, DT[ , sum(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
-test(2139.26, DT[ , sum(f), by=a], error="sum is not meaningful for factors")
-test(2139.27, DT[ , mean(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
-test(2139.28, DT[ , mean(l), by=a], error="GForce mean can only be applied to columns, not .SD or similar")
-test(2139.29, DT[ , mean(f), by=a], error="mean is not meaningful for factors")
-test(2139.30, DT[ , min(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
-test(2139.31, DT[ , min(l), by=a], error="GForce min can only be applied to columns, not .SD or similar")
-test(2139.32, DT[ , min(f), by=a], error="min is not meaningful for factors")
-test(2139.33, DT[ , max(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
-test(2139.34, DT[ , max(l), by=a], error="GForce max can only be applied to columns, not .SD or similar")
-test(2139.35, DT[ , max(f), by=a], error="max is not meaningful for factors")
-test(2139.36, DT[ , median(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
-test(2139.37, DT[ , median(l), by=a], error="GForce median can only be applied to columns, not .SD or similar")
-test(2139.38, DT[ , median(f), by=a], error="median is not meaningful for factors")
-test(2139.39, DT[ , var(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
-test(2139.40, DT[ , var(l), by=a], error="GForce var/sd can only be applied to columns, not .SD or similar")
-test(2139.41, DT[ , var(f), by=a], error="var/sd is not meaningful for factors")
-test(2139.42, DT[ , prod(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
-test(2139.43, DT[ , prod(l), by=a], error="GForce prod can only be applied to columns, not .SD or similar")
-test(2139.44, DT[ , prod(f), by=a], error="prod is not meaningful for factors")
+test(2139.26, DT[ , sum(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
+test(2139.27, DT[ , sum(f), by=a], error="sum is not meaningful for factors")
+test(2139.28, DT[ , mean(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
+test(2139.29, DT[ , mean(l), by=a], error="GForce mean can only be applied to columns, not .SD or similar")
+test(2139.30, DT[ , mean(f), by=a], error="mean is not meaningful for factors")
+test(2139.31, DT[ , min(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
+test(2139.32, DT[ , min(l), by=a], error="GForce min can only be applied to columns, not .SD or similar")
+test(2139.33, DT[ , min(f), by=a], error="min is not meaningful for factors")
+test(2139.34, DT[ , max(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
+test(2139.35, DT[ , max(l), by=a], error="GForce max can only be applied to columns, not .SD or similar")
+test(2139.36, DT[ , max(f), by=a], error="max is not meaningful for factors")
+test(2139.37, DT[ , median(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
+test(2139.38, DT[ , median(l), by=a], error="GForce median can only be applied to columns, not .SD or similar")
+test(2139.39, DT[ , median(f), by=a], error="median is not meaningful for factors")
+test(2139.40, DT[ , var(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
+test(2139.41, DT[ , var(l), by=a], error="GForce var/sd can only be applied to columns, not .SD or similar")
+test(2139.42, DT[ , var(f), by=a], error="var/sd is not meaningful for factors")
+test(2139.43, DT[ , prod(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
+test(2139.44, DT[ , prod(l), by=a], error="GForce prod can only be applied to columns, not .SD or similar")
+test(2139.45, DT[ , prod(f), by=a], error="prod is not meaningful for factors")
 options(old)
 
-test(2139.45, vecseq(NA, NA, NA), error="x must be an integer vector")
-test(2139.46, vecseq(1L, NA, NA), error="len must be an integer vector")
-test(2139.47, vecseq(1L, 1:2, NA), error="x and len must be the same length")
-test(2139.48, vecseq(1L, 1L, 's'), error="clamp must be a double vector length 1")
-test(2139.49, vecseq(1L, 1L, -1), error="clamp must be positive")
+test(2139.46, vecseq(NA, NA, NA), error="x must be an integer vector")
+test(2139.47, vecseq(1L, NA, NA), error="len must be an integer vector")
+test(2139.48, vecseq(1L, 1:2, NA), error="x and len must be the same length")
+test(2139.49, vecseq(1L, 1L, 's'), error="clamp must be a double vector length 1")
+test(2139.50, vecseq(1L, 1L, -1), error="clamp must be positive")
 
-test(2139.50, which_(1L, FALSE), error="Argument to 'which' must be logical")
+test(2139.51, which_(1L, FALSE), error="Argument to 'which' must be logical")
 
-test(2139.51, melt(data.table(1), variable.name=1), error="Argument 'variable.name' must be a character vector")
-test(2139.52, melt(data.table(1), value.name=1), error="Argument 'value.name' must be a character vector")
+test(2139.52, melt(data.table(1), variable.name=1), error="Argument 'variable.name' must be a character vector")
+test(2139.53, melt(data.table(1), value.name=1), error="Argument 'value.name' must be a character vector")
diff --git a/src/freadR.c b/src/freadR.c
index d8a15677a0..f2c05591fe 100644
--- a/src/freadR.c
+++ b/src/freadR.c
@@ -151,7 +151,7 @@ SEXP freadR(
   args.fill = LOGICAL(fillArg)[0];
   args.showProgress = LOGICAL(showProgressArg)[0];
   if (INTEGER(nThreadArg)[0]<1)
-    error(_("nThread(%d)<1"), INTEGER(nThreadArg)[0]);
+    error(_("Internal error: nThread(%d)<1"), INTEGER(nThreadArg)[0]); // # nocov
   args.nth = (uint32_t)INTEGER(nThreadArg)[0];
   args.verbose = verbose;
   args.warningsAreErrors = warningsAreErrors;
@@ -590,7 +590,7 @@ void pushBuffer(ThreadLocalFreadParsingContext *ctx)
       } else
       if (thisSize == 1) {
         if (type[j] > CT_BOOL8_L)
-          STOP(_("Field size is 1 but the field is of type %d\n"), type[j]);
+          STOP(_("Internal error: field size is 1 but the field is of type %d\n"), type[j]); // # nocov
         Rboolean *dest = (Rboolean *)LOGICAL(VECTOR_ELT(DT, resj)) + DTi;
         const char *src1 = (char*)buff1 + off1;
         for (int i=0; i<nRows; ++i) {
diff --git a/src/wrappers.c b/src/wrappers.c
index 95e206634e..d5379c6fc6 100644
--- a/src/wrappers.c
+++ b/src/wrappers.c
@@ -93,7 +93,7 @@ SEXP expandAltRep(SEXP x)
   // See extensive discussion in issue #2866
 
   if (TYPEOF(x) != VECSXP)
-    error(_("x isn't a VECSXP"));
+    error(_("Internal error: x isn't a VECSXP")); // # nocov
   for (int i=0; i<LENGTH(x); i++) {
     SEXP col = VECTOR_ELT(x,i);
     if (ALTREP(col)) {

From a3c4fa62b11bccaef0ab13543a82aa54bc28c396 Mon Sep 17 00:00:00 2001
From: Michael Chirico <michael.chirico@grabtaxi.com>
Date: Mon, 16 Mar 2020 00:05:53 +0800
Subject: [PATCH 19/23] test #s

---
 inst/tests/tests.Rraw | 68 +++++++++++++++++++++----------------------
 1 file changed, 34 insertions(+), 34 deletions(-)

diff --git a/inst/tests/tests.Rraw b/inst/tests/tests.Rraw
index c7eb1e42e9..ccd338721d 100644
--- a/inst/tests/tests.Rraw
+++ b/inst/tests/tests.Rraw
@@ -16878,49 +16878,49 @@ test(2139.19, fread(txt, select = c(1, 1)), error="Column number 1 ('a') has bee
 test(2139.20, fread(txt, colClasses=as.raw(0)), error="colClasses is not type list or character vector")
 test(2139.21, fread(txt, colClasses=list()), error="colClasses is type list but has no names")
 
-test(2139.20, setNumericRounding(1:2), error="Rounding level must be a length-1 integer or numeric vector")
-test(2139.21, setNumericRounding(-1), error="Rounding level must be 2, 1 or 0")
+test(2139.22, setNumericRounding(1:2), error="Rounding level must be a length-1 integer or numeric vector")
+test(2139.23, setNumericRounding(-1), error="Rounding level must be 2, 1 or 0")
 
 DT = data.table(1L)
 names(DT) = NULL
-test(2139.22, setcolorder(DT, 1L), error="data.table passed to setcolorder has no names")
+test(2139.24, setcolorder(DT, 1L), error="data.table passed to setcolorder has no names")
 
 # uniqueNlogical
-test(2139.23, uniqueN(NA, na.rm=1), error="na.rm must be TRUE or FALSE")
-test(2139.24, rleid(1, 1:2), error="All elements of input list must be of same length")
-test(2139.25, uniqlengths(1L, 1:3), error="Input argument 'n' to 'uniqlengths' must be an integer vector of length 1")
+test(2139.25, uniqueN(NA, na.rm=1), error="na.rm must be TRUE or FALSE")
+test(2139.26, rleid(1, 1:2), error="All elements of input list must be of same length")
+test(2139.27, uniqlengths(1L, 1:3), error="Input argument 'n' to 'uniqlengths' must be an integer vector of length 1")
 
 old = options(datatable.optimize = 2L)
 DT = data.table(a = 1:2, b = 1, f = factor(1), l = list(1))
-test(2139.26, DT[ , sum(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
-test(2139.27, DT[ , sum(f), by=a], error="sum is not meaningful for factors")
-test(2139.28, DT[ , mean(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
-test(2139.29, DT[ , mean(l), by=a], error="GForce mean can only be applied to columns, not .SD or similar")
-test(2139.30, DT[ , mean(f), by=a], error="mean is not meaningful for factors")
-test(2139.31, DT[ , min(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
-test(2139.32, DT[ , min(l), by=a], error="GForce min can only be applied to columns, not .SD or similar")
-test(2139.33, DT[ , min(f), by=a], error="min is not meaningful for factors")
-test(2139.34, DT[ , max(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
-test(2139.35, DT[ , max(l), by=a], error="GForce max can only be applied to columns, not .SD or similar")
-test(2139.36, DT[ , max(f), by=a], error="max is not meaningful for factors")
-test(2139.37, DT[ , median(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
-test(2139.38, DT[ , median(l), by=a], error="GForce median can only be applied to columns, not .SD or similar")
-test(2139.39, DT[ , median(f), by=a], error="median is not meaningful for factors")
-test(2139.40, DT[ , var(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
-test(2139.41, DT[ , var(l), by=a], error="GForce var/sd can only be applied to columns, not .SD or similar")
-test(2139.42, DT[ , var(f), by=a], error="var/sd is not meaningful for factors")
-test(2139.43, DT[ , prod(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
-test(2139.44, DT[ , prod(l), by=a], error="GForce prod can only be applied to columns, not .SD or similar")
-test(2139.45, DT[ , prod(f), by=a], error="prod is not meaningful for factors")
+test(2139.28, DT[ , sum(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
+test(2139.29, DT[ , sum(f), by=a], error="sum is not meaningful for factors")
+test(2139.30, DT[ , mean(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
+test(2139.31, DT[ , mean(l), by=a], error="GForce mean can only be applied to columns, not .SD or similar")
+test(2139.32, DT[ , mean(f), by=a], error="mean is not meaningful for factors")
+test(2139.33, DT[ , min(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
+test(2139.34, DT[ , min(l), by=a], error="GForce min can only be applied to columns, not .SD or similar")
+test(2139.35, DT[ , min(f), by=a], error="min is not meaningful for factors")
+test(2139.36, DT[ , max(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
+test(2139.37, DT[ , max(l), by=a], error="GForce max can only be applied to columns, not .SD or similar")
+test(2139.38, DT[ , max(f), by=a], error="max is not meaningful for factors")
+test(2139.39, DT[ , median(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
+test(2139.40, DT[ , median(l), by=a], error="GForce median can only be applied to columns, not .SD or similar")
+test(2139.41, DT[ , median(f), by=a], error="median is not meaningful for factors")
+test(2139.42, DT[ , var(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
+test(2139.43, DT[ , var(l), by=a], error="GForce var/sd can only be applied to columns, not .SD or similar")
+test(2139.44, DT[ , var(f), by=a], error="var/sd is not meaningful for factors")
+test(2139.45, DT[ , prod(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
+test(2139.46, DT[ , prod(l), by=a], error="GForce prod can only be applied to columns, not .SD or similar")
+test(2139.47, DT[ , prod(f), by=a], error="prod is not meaningful for factors")
 options(old)
 
-test(2139.46, vecseq(NA, NA, NA), error="x must be an integer vector")
-test(2139.47, vecseq(1L, NA, NA), error="len must be an integer vector")
-test(2139.48, vecseq(1L, 1:2, NA), error="x and len must be the same length")
-test(2139.49, vecseq(1L, 1L, 's'), error="clamp must be a double vector length 1")
-test(2139.50, vecseq(1L, 1L, -1), error="clamp must be positive")
+test(2139.48, vecseq(NA, NA, NA), error="x must be an integer vector")
+test(2139.49, vecseq(1L, NA, NA), error="len must be an integer vector")
+test(2139.50, vecseq(1L, 1:2, NA), error="x and len must be the same length")
+test(2139.51, vecseq(1L, 1L, 's'), error="clamp must be a double vector length 1")
+test(2139.52, vecseq(1L, 1L, -1), error="clamp must be positive")
 
-test(2139.51, which_(1L, FALSE), error="Argument to 'which' must be logical")
+test(2139.53, which_(1L, FALSE), error="Argument to 'which' must be logical")
 
-test(2139.52, melt(data.table(1), variable.name=1), error="Argument 'variable.name' must be a character vector")
-test(2139.53, melt(data.table(1), value.name=1), error="Argument 'value.name' must be a character vector")
+test(2139.54, melt(data.table(1), variable.name=1), error="Argument 'variable.name' must be a character vector")
+test(2139.55, melt(data.table(1), value.name=1), error="Argument 'value.name' must be a character vector")

From 5611feea3f9ca238f8b10aac9a3145623f2ec9d8 Mon Sep 17 00:00:00 2001
From: Michael Chirico <michael.chirico@grabtaxi.com>
Date: Mon, 16 Mar 2020 00:44:16 +0800
Subject: [PATCH 20/23] one more spate of tests for the night

---
 inst/tests/tests.Rraw | 6 ++++++
 src/bmerge.c          | 8 ++++----
 src/fsort.c           | 2 +-
 src/fwrite.c          | 8 ++++----
 src/subset.c          | 4 ++--
 5 files changed, 17 insertions(+), 11 deletions(-)

diff --git a/inst/tests/tests.Rraw b/inst/tests/tests.Rraw
index ccd338721d..6b8618c782 100644
--- a/inst/tests/tests.Rraw
+++ b/inst/tests/tests.Rraw
@@ -16924,3 +16924,9 @@ test(2139.53, which_(1L, FALSE), error="Argument to 'which' must be logical")
 
 test(2139.54, melt(data.table(1), variable.name=1), error="Argument 'variable.name' must be a character vector")
 test(2139.55, melt(data.table(1), value.name=1), error="Argument 'value.name' must be a character vector")
+
+DT1 = data.table(a=1)
+DT2 = data.table(a=2)
+test(2139.56, bmerge(DT1, DT2, 1, 1, roll = 'a', rollends = TRUE, verbose = TRUE, ops = NULL, nomatch = NULL, mult = 'all'), error="roll is character but not 'nearest'")
+
+test(2139.57, fsort(-1), error="Cannot yet handle negatives")
diff --git a/src/bmerge.c b/src/bmerge.c
index 0895d287f6..6f07012561 100644
--- a/src/bmerge.c
+++ b/src/bmerge.c
@@ -62,13 +62,13 @@ SEXP bmerge(SEXP iArg, SEXP xArg, SEXP icolsArg, SEXP xcolsArg, SEXP isorted, SE
     if (xcols[col]==NA_INTEGER)
       error(_("Internal error. xcols[%d] is NA"), col); // # nocov
     if (icols[col]>LENGTH(i) || icols[col]<1)
-      error(_("icols[%d]=%d outside range [1,length(i)=%d]"), col, icols[col], LENGTH(i));
+      error(_("Internal error: icols[%d]=%d outside range [1,length(i)=%d]"), col, icols[col], LENGTH(i)); // # nocov
     if (xcols[col]>LENGTH(x) || xcols[col]<1)
-      error(_("xcols[%d]=%d outside range [1,length(x)=%d]"), col, xcols[col], LENGTH(x));
+      error(_("Internal error: xcols[%d]=%d outside range [1,length(x)=%d]"), col, xcols[col], LENGTH(x)); // # nocov
     int it = TYPEOF(VECTOR_ELT(i, icols[col]-1));
     int xt = TYPEOF(VECTOR_ELT(x, xcols[col]-1));
     if (iN && it!=xt)
-      error(_("typeof x.%s (%s) != typeof i.%s (%s)"), CHAR(STRING_ELT(getAttrib(x,R_NamesSymbol),xcols[col]-1)), type2char(xt), CHAR(STRING_ELT(getAttrib(i,R_NamesSymbol),icols[col]-1)), type2char(it));
+      error(_("Internal error: typeof x.%s (%s) != typeof i.%s (%s)"), CHAR(STRING_ELT(getAttrib(x, R_NamesSymbol), xcols[col]-1)), type2char(xt), CHAR(STRING_ELT(getAttrib(i, R_NamesSymbol), icols[col]-1)), type2char(it)); // # nocov
   }
   // raise(SIGINT);
 
@@ -110,7 +110,7 @@ SEXP bmerge(SEXP iArg, SEXP xArg, SEXP icolsArg, SEXP xcolsArg, SEXP isorted, SE
 
   // nqmaxgrpArg
   if (!isInteger(nqmaxgrpArg) || length(nqmaxgrpArg) != 1 || INTEGER(nqmaxgrpArg)[0] <= 0)
-    error(_("Intrnal error: nqmaxgrpArg is not a positive length-1 integer vector")); // # nocov
+    error(_("Internal error: nqmaxgrpArg is not a positive length-1 integer vector")); // # nocov
   nqmaxgrp = INTEGER(nqmaxgrpArg)[0];
   if (nqmaxgrp>1 && mult == ALL) {
     // non-equi case with mult=ALL, may need reallocation
diff --git a/src/fsort.c b/src/fsort.c
index 4443576661..239ad731b7 100644
--- a/src/fsort.c
+++ b/src/fsort.c
@@ -109,7 +109,7 @@ SEXP fsort(SEXP x, SEXP verboseArg) {
     error(_("verbose must be TRUE or FALSE"));
   Rboolean verbose = LOGICAL(verboseArg)[0];
   if (!isNumeric(x))
-    error(_("x must be a vector of type 'double' currently"));
+    error(_("Internal error: x must be a vector of type 'double' currently")); // # nocov
   // TODO: not only detect if already sorted, but if it is, just return x to save the duplicate
 
   SEXP ansVec = PROTECT(allocVector(REALSXP, xlength(x)));
diff --git a/src/fwrite.c b/src/fwrite.c
index 011e0af699..19e2828007 100644
--- a/src/fwrite.c
+++ b/src/fwrite.c
@@ -611,7 +611,7 @@ void fwriteMain(fwriteMainArgs args)
   squashDateTime = args.squashDateTime;
 
   if (args.buffMB<1 || args.buffMB>1024)
-    STOP(_("buffMB=%d outside [1,1024]"), args.buffMB);
+    STOP(_("Internal error: buffMB=%d outside [1,1024]"), args.buffMB); // # nocov
   size_t buffSize = (size_t)1024*1024*args.buffMB;
 
   int eolLen=strlen(args.eol), naLen=strlen(args.na);
@@ -619,7 +619,7 @@ void fwriteMain(fwriteMainArgs args)
   //        we'd need `#define _POSIX_C_SOURCE 200809L` before #include <string.h> but that seems a step too far
   //        and platform specific. We prefer to be pure C99.
   if (eolLen<=0)
-    STOP(_("eol must be 1 or more bytes (usually either \\n or \\r\\n) but is length %d"), eolLen);
+    STOP(_("Internal error: eol must be 1 or more bytes (usually either \\n or \\r\\n) but is length %d"), eolLen); // # nocov
 
   if (verbose) {
     DTPRINT(_("Column writers: "));
@@ -713,7 +713,7 @@ void fwriteMain(fwriteMainArgs args)
   if (headerLen) {
     char *buff = malloc(headerLen);
     if (!buff)
-      STOP(_("Unable to allocate %d MiB for header: %s"), headerLen / 1024 / 1024, strerror(errno));
+      STOP(_("Unable to allocate %d MiB for header: %s"), headerLen / 1024 / 1024, strerror(errno)); // # nocov
     char *ch = buff;
     if (args.bom) {*ch++=(char)0xEF; *ch++=(char)0xBB; *ch++=(char)0xBF; }  // 3 appears above (search for "bom")
     memcpy(ch, args.yaml, yamlLen);
@@ -775,7 +775,7 @@ void fwriteMain(fwriteMainArgs args)
   if (args.nrow == 0) {
     if (verbose) DTPRINT(_("No data rows present (nrow==0)\n"));
     if (f!=-1 && CLOSE(f))
-      STOP(_("%s: '%s'"), strerror(errno), args.filename);
+      STOP(_("%s: '%s'"), strerror(errno), args.filename); // # nocov
     return;
   }
 
diff --git a/src/subset.c b/src/subset.c
index 39a6d18812..1de4d54a9f 100644
--- a/src/subset.c
+++ b/src/subset.c
@@ -258,7 +258,7 @@ SEXP subsetDT(SEXP x, SEXP rows, SEXP cols) { // API change needs update NEWS.md
     rows = PROTECT(convertNegAndZeroIdx(rows, max, ScalarLogical(TRUE))); nprotect++;
     const char *err = check_idx(rows, nrow, &anyNA, &orderedSubset);
     if (err!=NULL)
-      error(err);
+      error(err); // # nocov
   }
 
   if (!isInteger(cols))
@@ -266,7 +266,7 @@ SEXP subsetDT(SEXP x, SEXP rows, SEXP cols) { // API change needs update NEWS.md
   for (int i=0; i<LENGTH(cols); i++) {
     int this = INTEGER(cols)[i];
     if (this<1 || this>LENGTH(x))
-      error(_("Item %d of 'cols' is %d which is outside 1-based range [1,ncol(x)=%d]"), i+1, this, LENGTH(x));
+      error(_("Internal error: item %d of 'cols' is %d which is outside 1-based range [1,ncol(x)=%d]"), i+1, this, LENGTH(x)); // # nocov
   }
 
   int overAlloc = checkOverAlloc(GetOption(install("datatable.alloccol"), R_NilValue));

From 3c87dd73281fe6f296f9d0e2681512a6850b4eed Mon Sep 17 00:00:00 2001
From: Michael Chirico <michael.chirico@grabtaxi.com>
Date: Mon, 16 Mar 2020 08:30:14 +0800
Subject: [PATCH 21/23] cover all but one line

---
 inst/tests/tests.Rraw | 79 +++++++++++++++++++++----------------------
 src/forder.c          |  8 ++---
 src/fread.c           |  8 ++---
 src/freadR.c          |  4 +--
 src/uniqlist.c        |  2 +-
 5 files changed, 50 insertions(+), 51 deletions(-)

diff --git a/inst/tests/tests.Rraw b/inst/tests/tests.Rraw
index 6b8618c782..1fd32e6784 100644
--- a/inst/tests/tests.Rraw
+++ b/inst/tests/tests.Rraw
@@ -16873,60 +16873,59 @@ test(2139.14, fread(txt, sep=',', quote=','), error="sep == quote (',') is not a
 test(2139.15, fread(txt, dec='&'), error="dec='&' not allowed")
 test(2139.16, fread(txt, quote='.', dec='.'), error="quote == dec ('.') is not allowed")
 test(2139.17, fread(txt, integer64=letters), error="'integer64' must be a single character string")
-test(2139.18, fread(txt, colClasses=list()), error="colClasses is type list but has no names")
-test(2139.19, fread(txt, select = c(1, 1)), error="Column number 1 ('a') has been selected twice by select=")
-test(2139.20, fread(txt, colClasses=as.raw(0)), error="colClasses is not type list or character vector")
-test(2139.21, fread(txt, colClasses=list()), error="colClasses is type list but has no names")
+test(2139.18, fread(txt, select = c(1, 1)), error="Column number 1 ('a') has been selected twice by select=")
 
-test(2139.22, setNumericRounding(1:2), error="Rounding level must be a length-1 integer or numeric vector")
-test(2139.23, setNumericRounding(-1), error="Rounding level must be 2, 1 or 0")
+test(2139.19, setNumericRounding(1:2), error="Rounding level must be a length-1 integer or numeric vector")
+test(2139.20, setNumericRounding(-1), error="Rounding level must be 2, 1 or 0")
 
 DT = data.table(1L)
 names(DT) = NULL
-test(2139.24, setcolorder(DT, 1L), error="data.table passed to setcolorder has no names")
+test(2139.21, setcolorder(DT, 1L), error="data.table passed to setcolorder has no names")
 
 # uniqueNlogical
-test(2139.25, uniqueN(NA, na.rm=1), error="na.rm must be TRUE or FALSE")
-test(2139.26, rleid(1, 1:2), error="All elements of input list must be of same length")
-test(2139.27, uniqlengths(1L, 1:3), error="Input argument 'n' to 'uniqlengths' must be an integer vector of length 1")
+test(2139.22, uniqueN(NA, na.rm=1), error="na.rm must be TRUE or FALSE")
+test(2139.23, rleid(1, 1:2), error="All elements of input list must be of same length")
+test(2139.24, uniqlengths(1L, 1:3), error="Input argument 'n' to 'uniqlengths' must be an integer vector of length 1")
 
 old = options(datatable.optimize = 2L)
 DT = data.table(a = 1:2, b = 1, f = factor(1), l = list(1))
-test(2139.28, DT[ , sum(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
-test(2139.29, DT[ , sum(f), by=a], error="sum is not meaningful for factors")
-test(2139.30, DT[ , mean(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
-test(2139.31, DT[ , mean(l), by=a], error="GForce mean can only be applied to columns, not .SD or similar")
-test(2139.32, DT[ , mean(f), by=a], error="mean is not meaningful for factors")
-test(2139.33, DT[ , min(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
-test(2139.34, DT[ , min(l), by=a], error="GForce min can only be applied to columns, not .SD or similar")
-test(2139.35, DT[ , min(f), by=a], error="min is not meaningful for factors")
-test(2139.36, DT[ , max(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
-test(2139.37, DT[ , max(l), by=a], error="GForce max can only be applied to columns, not .SD or similar")
-test(2139.38, DT[ , max(f), by=a], error="max is not meaningful for factors")
-test(2139.39, DT[ , median(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
-test(2139.40, DT[ , median(l), by=a], error="GForce median can only be applied to columns, not .SD or similar")
-test(2139.41, DT[ , median(f), by=a], error="median is not meaningful for factors")
-test(2139.42, DT[ , var(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
-test(2139.43, DT[ , var(l), by=a], error="GForce var/sd can only be applied to columns, not .SD or similar")
-test(2139.44, DT[ , var(f), by=a], error="var/sd is not meaningful for factors")
-test(2139.45, DT[ , prod(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
-test(2139.46, DT[ , prod(l), by=a], error="GForce prod can only be applied to columns, not .SD or similar")
-test(2139.47, DT[ , prod(f), by=a], error="prod is not meaningful for factors")
+test(2139.25, DT[ , sum(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
+test(2139.26, DT[ , sum(f), by=a], error="sum is not meaningful for factors")
+test(2139.27, DT[ , mean(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
+test(2139.28, DT[ , mean(l), by=a], error="GForce mean can only be applied to columns, not .SD or similar")
+test(2139.29, DT[ , mean(f), by=a], error="mean is not meaningful for factors")
+test(2139.30, DT[ , min(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
+test(2139.31, DT[ , min(l), by=a], error="GForce min can only be applied to columns, not .SD or similar")
+test(2139.32, DT[ , min(f), by=a], error="min is not meaningful for factors")
+test(2139.33, DT[ , max(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
+test(2139.34, DT[ , max(l), by=a], error="GForce max can only be applied to columns, not .SD or similar")
+test(2139.35, DT[ , max(f), by=a], error="max is not meaningful for factors")
+test(2139.36, DT[ , median(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
+test(2139.37, DT[ , median(l), by=a], error="GForce median can only be applied to columns, not .SD or similar")
+test(2139.38, DT[ , median(f), by=a], error="median is not meaningful for factors")
+test(2139.39, DT[ , var(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
+test(2139.40, DT[ , var(l), by=a], error="GForce var/sd can only be applied to columns, not .SD or similar")
+test(2139.41, DT[ , var(f), by=a], error="var/sd is not meaningful for factors")
+test(2139.42, DT[ , prod(b, na.rm=1), by=a], error="na.rm must be TRUE or FALSE")
+test(2139.43, DT[ , prod(l), by=a], error="GForce prod can only be applied to columns, not .SD or similar")
+test(2139.44, DT[ , prod(f), by=a], error="prod is not meaningful for factors")
 options(old)
 
-test(2139.48, vecseq(NA, NA, NA), error="x must be an integer vector")
-test(2139.49, vecseq(1L, NA, NA), error="len must be an integer vector")
-test(2139.50, vecseq(1L, 1:2, NA), error="x and len must be the same length")
-test(2139.51, vecseq(1L, 1L, 's'), error="clamp must be a double vector length 1")
-test(2139.52, vecseq(1L, 1L, -1), error="clamp must be positive")
+test(2139.45, vecseq(NA, NA, NA), error="x must be an integer vector")
+test(2139.46, vecseq(1L, NA, NA), error="len must be an integer vector")
+test(2139.47, vecseq(1L, 1:2, NA), error="x and len must be the same length")
+test(2139.48, vecseq(1L, 1L, 's'), error="clamp must be a double vector length 1")
+test(2139.49, vecseq(1L, 1L, -1), error="clamp must be positive")
 
-test(2139.53, which_(1L, FALSE), error="Argument to 'which' must be logical")
+test(2139.50, which_(1L, FALSE), error="Argument to 'which' must be logical")
 
-test(2139.54, melt(data.table(1), variable.name=1), error="Argument 'variable.name' must be a character vector")
-test(2139.55, melt(data.table(1), value.name=1), error="Argument 'value.name' must be a character vector")
+test(2139.51, melt(data.table(1), variable.name=1), error="Argument 'variable.name' must be a character vector")
+test(2139.52, melt(data.table(1), value.name=1), error="Argument 'value.name' must be a character vector")
 
 DT1 = data.table(a=1)
 DT2 = data.table(a=2)
-test(2139.56, bmerge(DT1, DT2, 1, 1, roll = 'a', rollends = TRUE, verbose = TRUE, ops = NULL, nomatch = NULL, mult = 'all'), error="roll is character but not 'nearest'")
+test(2139.53, bmerge(DT1, DT2, 1, 1, roll = 'a', rollends = TRUE, verbose = TRUE, ops = NULL, nomatch = NULL, mult = 'all'), error="roll is character but not 'nearest'")
 
-test(2139.57, fsort(-1), error="Cannot yet handle negatives")
+test(2139.54, fsort(-1), error="Cannot yet handle negatives")
+
+test(2139.55, binary('a'), error="x must be type 'double'")
diff --git a/src/forder.c b/src/forder.c
index d11252e84b..4d762207c0 100644
--- a/src/forder.c
+++ b/src/forder.c
@@ -1283,7 +1283,7 @@ SEXP fsorted(SEXP x)
   const int n = length(x);
   if (n <= 1) return(ScalarLogical(TRUE));
   if (!isVectorAtomic(x))
-    STOP(_("is.sorted (R level) and fsorted (C level) only to be used on vectors. If needed on a list/data.table, you'll need the order anyway if not sorted, so use if (length(o<-forder(...))) for efficiency in one step, or equivalent at C level"));
+    STOP(_("Internal error: is.sorted (R level) and fsorted (C level) only to be used on vectors. If needed on a list/data.table, you'll need the order anyway if not sorted, so use if (length(o<-forder(...))) for efficiency in one step, or equivalent at C level")); // # nocov
   int i=1;
   switch(TYPEOF(x)) {
   case INTSXP : case LGLSXP : {
@@ -1325,13 +1325,13 @@ SEXP isOrderedSubset(SEXP x, SEXP nrowArg)
 // Ignores 0s but heeds NAs and any out-of-range (which result in NA)
 {
   if (!isNull(x) && !isInteger(x))
-    error(_("x must be either NULL or an integer vector"));
+    error(_("Internal error: x must be either NULL or an integer vector")); // # nocov
   if (length(x)<=1) return(ScalarLogical(TRUE));  // a single NA when length(x)==1 is ordered (e.g. tests 128 & 130) otherwise anyNA => FALSE
   if (!isInteger(nrowArg) || LENGTH(nrowArg)!=1)
-    error(_("nrow must be integer vector length 1"));
+    error(_("Internal error: nrow must be integer vector length 1")); // # nocov
   const int nrow = INTEGER(nrowArg)[0];
   if (nrow<0)
-    error(_("nrow==%d but must be >=0"), nrow);
+    error(_("Internal error: nrow==%d but must be >=0"), nrow); // # nocov
   const int *xd = INTEGER(x), xlen=LENGTH(x);
   for (int i=0, last=INT_MIN; i<xlen; ++i) {
     int elem = xd[i];
diff --git a/src/fread.c b/src/fread.c
index 85130c0b4b..6221ba5dc5 100644
--- a/src/fread.c
+++ b/src/fread.c
@@ -1219,7 +1219,7 @@ int freadMain(freadMainArgs _args) {
     #ifndef WIN32
       int fd = open(fnam, O_RDONLY);
       if (fd==-1)
-        STOP(_("file not found: %s"),fnam);
+        STOP(_("file not found: %s"), fnam); // # nocov
       struct stat stat_buf;
       if (fstat(fd, &stat_buf) == -1) {
         close(fd);                                                     // # nocov
@@ -1228,7 +1228,7 @@ int freadMain(freadMainArgs _args) {
       fileSize = (size_t) stat_buf.st_size;
       if (fileSize == 0) {
         close(fd);
-        STOP(_("File is empty: %s"), fnam);
+        STOP(_("File is empty: %s"), fnam); // # nocov
       }
       if (verbose) DTPRINT(_("  File opened, size = %s.\n"), filesize_to_str(fileSize));
 
@@ -1798,7 +1798,7 @@ int freadMain(freadMainArgs _args) {
       type =    (int8_t *)realloc(type,    (size_t)tt * sizeof(int8_t));
       tmpType = (int8_t *)realloc(tmpType, (size_t)tt * sizeof(int8_t));
       if (!type || !tmpType)
-        STOP(_("Failed to realloc 2 x %d bytes for type and tmpType: %s"), tt, strerror(errno));
+        STOP(_("Failed to realloc 2 x %d bytes for type and tmpType: %s"), tt, strerror(errno)); // # nocov
       for (int j=ncol; j<tt; j++) { tmpType[j] = type[j] = type0; }
       ncol = tt;
     }
@@ -1950,7 +1950,7 @@ int freadMain(freadMainArgs _args) {
   rowSize8 = 0;
   size = (int8_t *)malloc((size_t)ncol * sizeof(int8_t));  // TODO: remove size[] when we implement Pasha's idea to += size inside processor
   if (!size)
-    STOP(_("Failed to allocate %d bytes for size array: %s"), ncol, strerror(errno));
+    STOP(_("Failed to allocate %d bytes for size array: %s"), ncol, strerror(errno)); // # nocov
   nStringCols = 0;
   nNonStringCols = 0;
   for (int j=0; j<ncol; j++) {
diff --git a/src/freadR.c b/src/freadR.c
index f2c05591fe..43aae525ac 100644
--- a/src/freadR.c
+++ b/src/freadR.c
@@ -349,10 +349,10 @@ bool userOverride(int8_t *type, lenOff *colNames, const char *anchor, const int
       UNPROTECT(1); // typeEnum_idx
     } else {
       if (!isNewList(colClassesSxp))
-        STOP(_("colClasses is type '%s' but should be list or character"), type2char(TYPEOF(colClassesSxp)));
+        STOP(_("Internal error: colClasses is type '%s' but should be list or character"), type2char(TYPEOF(colClassesSxp)));
       SEXP listNames = PROTECT(getAttrib(colClassesSxp, R_NamesSymbol));  // rchk wanted this protected
       if (!length(listNames))
-        STOP(_("colClasses is type list but has no names"));
+        STOP(_("Internal error: colClasses is type list but has no names"));
       SEXP typeEnum_idx = PROTECT(chmatch(listNames, typeRName_sxp, NUT));
 
       int *selectRankD = NULL, rank = 1;
diff --git a/src/uniqlist.c b/src/uniqlist.c
index d7c16a4ebd..e73bc0269d 100644
--- a/src/uniqlist.c
+++ b/src/uniqlist.c
@@ -273,7 +273,7 @@ SEXP nestedid(SEXP l, SEXP cols, SEXP order, SEXP grps, SEXP resetvals, SEXP mul
     error(_("Internal error: nrows[%d]>0 but ngrps==0"), nrows); // # nocov
   R_len_t resetctr=0, rlen = length(resetvals) ? INTEGER(resetvals)[0] : 0;
   if (!isInteger(cols) || ncols == 0)
-    error(_("cols must be an integer vector of positive length"));
+    error(_("Internal error: cols must be an integer vector of positive length")); // # nocov
   // mult arg
   enum {ALL, FIRST, LAST} mult = ALL;
   if (!strcmp(CHAR(STRING_ELT(multArg, 0)), "all")) mult = ALL;

From 95e88f8afe3bd79bd1cd90d03578e0e3855c3acd Mon Sep 17 00:00:00 2001
From: Michael Chirico <michael.chirico@grabtaxi.com>
Date: Mon, 16 Mar 2020 08:48:41 +0800
Subject: [PATCH 22/23] missed nocov

---
 src/freadR.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/freadR.c b/src/freadR.c
index 43aae525ac..d56eb1438b 100644
--- a/src/freadR.c
+++ b/src/freadR.c
@@ -349,10 +349,10 @@ bool userOverride(int8_t *type, lenOff *colNames, const char *anchor, const int
       UNPROTECT(1); // typeEnum_idx
     } else {
       if (!isNewList(colClassesSxp))
-        STOP(_("Internal error: colClasses is type '%s' but should be list or character"), type2char(TYPEOF(colClassesSxp)));
+        STOP(_("Internal error: colClasses is type '%s' but should be list or character"), type2char(TYPEOF(colClassesSxp))); // # nocov
       SEXP listNames = PROTECT(getAttrib(colClassesSxp, R_NamesSymbol));  // rchk wanted this protected
       if (!length(listNames))
-        STOP(_("Internal error: colClasses is type list but has no names"));
+        STOP(_("Internal error: colClasses is type list but has no names")); // # nocov
       SEXP typeEnum_idx = PROTECT(chmatch(listNames, typeRName_sxp, NUT));
 
       int *selectRankD = NULL, rank = 1;

From 4e69db64b260cd2f2801b3887755e6b419e04aac Mon Sep 17 00:00:00 2001
From: Michael Chirico <michael.chirico@grabtaxi.com>
Date: Mon, 16 Mar 2020 09:18:26 +0800
Subject: [PATCH 23/23] one more nocov

---
 src/fread.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/fread.c b/src/fread.c
index 6221ba5dc5..3a8c6340d8 100644
--- a/src/fread.c
+++ b/src/fread.c
@@ -1222,12 +1222,12 @@ int freadMain(freadMainArgs _args) {
         STOP(_("file not found: %s"), fnam); // # nocov
       struct stat stat_buf;
       if (fstat(fd, &stat_buf) == -1) {
-        close(fd);                                                     // # nocov
+        close(fd);                                                        // # nocov
         STOP(_("Opened file ok but couldn't obtain its size: %s"), fnam); // # nocov
       }
       fileSize = (size_t) stat_buf.st_size;
       if (fileSize == 0) {
-        close(fd);
+        close(fd);                          // # nocov
         STOP(_("File is empty: %s"), fnam); // # nocov
       }
       if (verbose) DTPRINT(_("  File opened, size = %s.\n"), filesize_to_str(fileSize));