Running 'build_mm.R' [1s/1s]
  Running 'calc_fdr.R' [1s/1s]
  Running 'gcContent_ms.R' [0s/0s]
  Running 'groupByGC_ms.R' [1s/1s]
  Running 'makeFdrPlot.R' [1s/1s]
  Running 'output_sites.R' [1s/2s]
  Running 'read_ms.R' [0s/1s]
  Running 'read_pwm.R' [1s/2s]
  Running 'score_ms.R' [1s/2s]
  Running 'simulate_ms.R' [1s/2s]
Running the tests in 'tests/build_mm.R' failed.
Complete output:
  > require("rtfbs")
  Loading required package: rtfbs
  > exampleArchive <- system.file("extdata", "NRSF.zip", package="rtfbs")
  > seqFile <- "input.fas"
  > unzip(exampleArchive, seqFile)
  > # Read in FASTA file "input.fas" from the examples into an 
  > #   MS (multiple sequences) object
  > ms <- read.ms(seqFile)
  > # Build a 3rd order Markov Model to represent the sequences
  > #   in the MS object "ms".  The Model will be a list of
  > #   matrices  corrisponding in size to the order of the 
  > #   Markov Model
  > mm <- build.mm(ms, 3);
   ----------- FAILURE REPORT -------------- 
   --- failure: the condition has length > 1 ---
   --- srcref --- 
  : 
   --- package (from environment) --- 
  rtfbs
   --- call from context --- 
  label.matrix(mat[[entry]], columnsOnly)
   --- call from argument --- 
  if (class(mat) == "list") {
      for (entry in 1:length(mat)) {
          mat[[entry]] <- label.matrix(mat[[entry]], columnsOnly)
      }
  } else if (class(mat) == "matrix") {
      name <- list()
      bases <- list("A", "C", "G", "T")
      if (columnsOnly == FALSE) {
          if (nrow(mat) == 1) {
              name = c("*")
          }
          else {
              for (row in 0:(nrow(mat))) {
                  name[row] <- ""
                  for (s in 1:log(nrow(mat), 4)) {
                    base <- (ceiling(row/(4^(s - 1)))%%4)
                    if (base == 0) 
                      base <- 4
                    name[row] <- paste(bases[base], name[row], 
                      sep = "")
                  }
              }
          }
          rownames(mat) <- name
      }
      colnames(mat) <- bases
  }
   --- R stacktrace ---
  where 1: label.matrix(mat[[entry]], columnsOnly)
  where 2: label.matrix(x)
  where 3: build.mm(ms, 3)
  
   --- value of length: 2 type: logical ---
  [1] FALSE FALSE
   --- function from context --- 
  function (mat, columnsOnly = FALSE) 
  {
      check.arg(columnsOnly, "columnsOnly", "logical", null.OK = FALSE)
      if (class(mat) == "list") {
          for (entry in 1:length(mat)) {
              mat[[entry]] <- label.matrix(mat[[entry]], columnsOnly)
          }
      }
      else if (class(mat) == "matrix") {
          name <- list()
          bases <- list("A", "C", "G", "T")
          if (columnsOnly == FALSE) {
              if (nrow(mat) == 1) {
                  name = c("*")
              }
              else {
                  for (row in 0:(nrow(mat))) {
                    name[row] <- ""
                    for (s in 1:log(nrow(mat), 4)) {
                      base <- (ceiling(row/(4^(s - 1)))%%4)
                      if (base == 0) 
                        base <- 4
                      name[row] <- paste(bases[base], name[row], 
                        sep = "")
                    }
                  }
              }
              rownames(mat) <- name
          }
          colnames(mat) <- bases
      }
      mat
  }
  <bytecode: 0x4e4d9a8>
  <environment: namespace:rtfbs>
   --- function search by body ---
  Function label.matrix in namespace rtfbs has this body.
   ----------- END OF FAILURE REPORT -------------- 
  Error in if (class(mat) == "list") { : the condition has length > 1
  Calls: build.mm -> label.matrix -> label.matrix
  Execution halted
Running the tests in 'tests/calc_fdr.R' failed.
Complete output:
  > require("rtfbs")
  Loading required package: rtfbs
  > exampleArchive <- system.file("extdata", "NRSF.zip", package="rtfbs")
  > seqFile <- "input.fas"
  > unzip(exampleArchive, seqFile)
  > # Read in FASTA file "input.fas" from the examples into an 
  > #   MS (multiple sequences) object
  > ms <- read.ms(seqFile);
  > pwmFile <- "pwm.meme"
  > unzip(exampleArchive, pwmFile)
  > # Read in Position Weight Matrix (PWM) from MEME file from
  > #  the examples into a Matrix object
  > pwm <- read.pwm(pwmFile)
   ----------- FAILURE REPORT -------------- 
   --- failure: the condition has length > 1 ---
   --- srcref --- 
  : 
   --- package (from environment) --- 
  rtfbs
   --- call from context --- 
  label.matrix(x, columnsOnly = TRUE)
   --- call from argument --- 
  if (class(mat) == "list") {
      for (entry in 1:length(mat)) {
          mat[[entry]] <- label.matrix(mat[[entry]], columnsOnly)
      }
  } else if (class(mat) == "matrix") {
      name <- list()
      bases <- list("A", "C", "G", "T")
      if (columnsOnly == FALSE) {
          if (nrow(mat) == 1) {
              name = c("*")
          }
          else {
              for (row in 0:(nrow(mat))) {
                  name[row] <- ""
                  for (s in 1:log(nrow(mat), 4)) {
                    base <- (ceiling(row/(4^(s - 1)))%%4)
                    if (base == 0) 
                      base <- 4
                    name[row] <- paste(bases[base], name[row], 
                      sep = "")
                  }
              }
          }
          rownames(mat) <- name
      }
      colnames(mat) <- bases
  }
   --- R stacktrace ---
  where 1: label.matrix(x, columnsOnly = TRUE)
  where 2: read.pwm(pwmFile)
  
   --- value of length: 2 type: logical ---
  [1] FALSE FALSE
   --- function from context --- 
  function (mat, columnsOnly = FALSE) 
  {
      check.arg(columnsOnly, "columnsOnly", "logical", null.OK = FALSE)
      if (class(mat) == "list") {
          for (entry in 1:length(mat)) {
              mat[[entry]] <- label.matrix(mat[[entry]], columnsOnly)
          }
      }
      else if (class(mat) == "matrix") {
          name <- list()
          bases <- list("A", "C", "G", "T")
          if (columnsOnly == FALSE) {
              if (nrow(mat) == 1) {
                  name = c("*")
              }
              else {
                  for (row in 0:(nrow(mat))) {
                    name[row] <- ""
                    for (s in 1:log(nrow(mat), 4)) {
                      base <- (ceiling(row/(4^(s - 1)))%%4)
                      if (base == 0) 
                        base <- 4
                      name[row] <- paste(bases[base], name[row], 
                        sep = "")
                    }
                  }
              }
              rownames(mat) <- name
          }
          colnames(mat) <- bases
      }
      mat
  }
  <bytecode: 0x38c77c8>
  <environment: namespace:rtfbs>
   --- function search by body ---
  Function label.matrix in namespace rtfbs has this body.
   ----------- END OF FAILURE REPORT -------------- 
  Error in if (class(mat) == "list") { : the condition has length > 1
  Calls: read.pwm -> label.matrix
  Execution halted
Running the tests in 'tests/makeFdrPlot.R' failed.
Complete output:
  > require("rtfbs")
  Loading required package: rtfbs
  > exampleArchive <- system.file("extdata", "NRSF.zip", package="rtfbs")
  > seqFile <- "input.fas"
  > unzip(exampleArchive, seqFile)
  > # Read in FASTA file "input.fas" from the examples into an 
  > #   MS (multiple sequences) object
  > ms <- read.ms(seqFile);
  > pwmFile <- "pwm.meme"
  > unzip(exampleArchive, pwmFile)
  > # Read in Position Weight Matrix (PWM) from MEME file from
  > #  the examples into a Matrix object
  > pwm <- read.pwm(pwmFile)
   ----------- FAILURE REPORT -------------- 
   --- failure: the condition has length > 1 ---
   --- srcref --- 
  : 
   --- package (from environment) --- 
  rtfbs
   --- call from context --- 
  label.matrix(x, columnsOnly = TRUE)
   --- call from argument --- 
  if (class(mat) == "list") {
      for (entry in 1:length(mat)) {
          mat[[entry]] <- label.matrix(mat[[entry]], columnsOnly)
      }
  } else if (class(mat) == "matrix") {
      name <- list()
      bases <- list("A", "C", "G", "T")
      if (columnsOnly == FALSE) {
          if (nrow(mat) == 1) {
              name = c("*")
          }
          else {
              for (row in 0:(nrow(mat))) {
                  name[row] <- ""
                  for (s in 1:log(nrow(mat), 4)) {
                    base <- (ceiling(row/(4^(s - 1)))%%4)
                    if (base == 0) 
                      base <- 4
                    name[row] <- paste(bases[base], name[row], 
                      sep = "")
                  }
              }
          }
          rownames(mat) <- name
      }
      colnames(mat) <- bases
  }
   --- R stacktrace ---
  where 1: label.matrix(x, columnsOnly = TRUE)
  where 2: read.pwm(pwmFile)
  
   --- value of length: 2 type: logical ---
  [1] FALSE FALSE
   --- function from context --- 
  function (mat, columnsOnly = FALSE) 
  {
      check.arg(columnsOnly, "columnsOnly", "logical", null.OK = FALSE)
      if (class(mat) == "list") {
          for (entry in 1:length(mat)) {
              mat[[entry]] <- label.matrix(mat[[entry]], columnsOnly)
          }
      }
      else if (class(mat) == "matrix") {
          name <- list()
          bases <- list("A", "C", "G", "T")
          if (columnsOnly == FALSE) {
              if (nrow(mat) == 1) {
                  name = c("*")
              }
              else {
                  for (row in 0:(nrow(mat))) {
                    name[row] <- ""
                    for (s in 1:log(nrow(mat), 4)) {
                      base <- (ceiling(row/(4^(s - 1)))%%4)
                      if (base == 0) 
                        base <- 4
                      name[row] <- paste(bases[base], name[row], 
                        sep = "")
                    }
                  }
              }
              rownames(mat) <- name
          }
          colnames(mat) <- bases
      }
      mat
  }
  <bytecode: 0x2fec7c8>
  <environment: namespace:rtfbs>
   --- function search by body ---
  Function label.matrix in namespace rtfbs has this body.
   ----------- END OF FAILURE REPORT -------------- 
  Error in if (class(mat) == "list") { : the condition has length > 1
  Calls: read.pwm -> label.matrix
  Execution halted
Running the tests in 'tests/output_sites.R' failed.
Complete output:
  > require("rtfbs")
  Loading required package: rtfbs
  > exampleArchive <- system.file("extdata", "NRSF.zip", package="rtfbs")
  > seqFile <- "input.fas"
  > unzip(exampleArchive, seqFile)
  > # Read in FASTA file "input.fas" from the examples into an 
  > #   MS (multiple sequences) object
  > ms <- read.ms(seqFile);
  > pwmFile <- "pwm.meme"
  > unzip(exampleArchive, pwmFile)
  > # Read in Position Weight Matrix (PWM) from MEME file from
  > #  the examples into a Matrix object
  > pwm <- read.pwm(pwmFile)
   ----------- FAILURE REPORT -------------- 
   --- failure: the condition has length > 1 ---
   --- srcref --- 
  : 
   --- package (from environment) --- 
  rtfbs
   --- call from context --- 
  label.matrix(x, columnsOnly = TRUE)
   --- call from argument --- 
  if (class(mat) == "list") {
      for (entry in 1:length(mat)) {
          mat[[entry]] <- label.matrix(mat[[entry]], columnsOnly)
      }
  } else if (class(mat) == "matrix") {
      name <- list()
      bases <- list("A", "C", "G", "T")
      if (columnsOnly == FALSE) {
          if (nrow(mat) == 1) {
              name = c("*")
          }
          else {
              for (row in 0:(nrow(mat))) {
                  name[row] <- ""
                  for (s in 1:log(nrow(mat), 4)) {
                    base <- (ceiling(row/(4^(s - 1)))%%4)
                    if (base == 0) 
                      base <- 4
                    name[row] <- paste(bases[base], name[row], 
                      sep = "")
                  }
              }
          }
          rownames(mat) <- name
      }
      colnames(mat) <- bases
  }
   --- R stacktrace ---
  where 1: label.matrix(x, columnsOnly = TRUE)
  where 2: read.pwm(pwmFile)
  
   --- value of length: 2 type: logical ---
  [1] FALSE FALSE
   --- function from context --- 
  function (mat, columnsOnly = FALSE) 
  {
      check.arg(columnsOnly, "columnsOnly", "logical", null.OK = FALSE)
      if (class(mat) == "list") {
          for (entry in 1:length(mat)) {
              mat[[entry]] <- label.matrix(mat[[entry]], columnsOnly)
          }
      }
      else if (class(mat) == "matrix") {
          name <- list()
          bases <- list("A", "C", "G", "T")
          if (columnsOnly == FALSE) {
              if (nrow(mat) == 1) {
                  name = c("*")
              }
              else {
                  for (row in 0:(nrow(mat))) {
                    name[row] <- ""
                    for (s in 1:log(nrow(mat), 4)) {
                      base <- (ceiling(row/(4^(s - 1)))%%4)
                      if (base == 0) 
                        base <- 4
                      name[row] <- paste(bases[base], name[row], 
                        sep = "")
                    }
                  }
              }
              rownames(mat) <- name
          }
          colnames(mat) <- bases
      }
      mat
  }
  <bytecode: 0x30667c8>
  <environment: namespace:rtfbs>
   --- function search by body ---
  Function label.matrix in namespace rtfbs has this body.
   ----------- END OF FAILURE REPORT -------------- 
  Error in if (class(mat) == "list") { : the condition has length > 1
  Calls: read.pwm -> label.matrix
  Execution halted
Running the tests in 'tests/read_pwm.R' failed.
Complete output:
  > require("rtfbs")
  Loading required package: rtfbs
  > exampleArchive <- system.file("extdata", "NRSF.zip", package="rtfbs")
  > pwmFile <- "pwm.meme"
  > unzip(exampleArchive, pwmFile)
  > # Read in Position Weight Matrix (PWM) from MEME file from
  > #  the examples into a Matrix object
  > pwm <- read.pwm(pwmFile)
   ----------- FAILURE REPORT -------------- 
   --- failure: the condition has length > 1 ---
   --- srcref --- 
  : 
   --- package (from environment) --- 
  rtfbs
   --- call from context --- 
  label.matrix(x, columnsOnly = TRUE)
   --- call from argument --- 
  if (class(mat) == "list") {
      for (entry in 1:length(mat)) {
          mat[[entry]] <- label.matrix(mat[[entry]], columnsOnly)
      }
  } else if (class(mat) == "matrix") {
      name <- list()
      bases <- list("A", "C", "G", "T")
      if (columnsOnly == FALSE) {
          if (nrow(mat) == 1) {
              name = c("*")
          }
          else {
              for (row in 0:(nrow(mat))) {
                  name[row] <- ""
                  for (s in 1:log(nrow(mat), 4)) {
                    base <- (ceiling(row/(4^(s - 1)))%%4)
                    if (base == 0) 
                      base <- 4
                    name[row] <- paste(bases[base], name[row], 
                      sep = "")
                  }
              }
          }
          rownames(mat) <- name
      }
      colnames(mat) <- bases
  }
   --- R stacktrace ---
  where 1: label.matrix(x, columnsOnly = TRUE)
  where 2: read.pwm(pwmFile)
  
   --- value of length: 2 type: logical ---
  [1] FALSE FALSE
   --- function from context --- 
  function (mat, columnsOnly = FALSE) 
  {
      check.arg(columnsOnly, "columnsOnly", "logical", null.OK = FALSE)
      if (class(mat) == "list") {
          for (entry in 1:length(mat)) {
              mat[[entry]] <- label.matrix(mat[[entry]], columnsOnly)
          }
      }
      else if (class(mat) == "matrix") {
          name <- list()
          bases <- list("A", "C", "G", "T")
          if (columnsOnly == FALSE) {
              if (nrow(mat) == 1) {
                  name = c("*")
              }
              else {
                  for (row in 0:(nrow(mat))) {
                    name[row] <- ""
                    for (s in 1:log(nrow(mat), 4)) {
                      base <- (ceiling(row/(4^(s - 1)))%%4)
                      if (base == 0) 
                        base <- 4
                      name[row] <- paste(bases[base], name[row], 
                        sep = "")
                    }
                  }
              }
              rownames(mat) <- name
          }
          colnames(mat) <- bases
      }
      mat
  }
  <bytecode: 0x3de3d90>
  <environment: namespace:rtfbs>
   --- function search by body ---
  Function label.matrix in namespace rtfbs has this body.
   ----------- END OF FAILURE REPORT -------------- 
  Error in if (class(mat) == "list") { : the condition has length > 1
  Calls: read.pwm -> label.matrix
  Execution halted
Running the tests in 'tests/score_ms.R' failed.
Complete output:
  > require("rtfbs")
  Loading required package: rtfbs
  > exampleArchive <- system.file("extdata", "NRSF.zip", package="rtfbs")
  > seqFile <- "input.fas"
  > unzip(exampleArchive, seqFile)
  > # Read in FASTA file "input.fas" from the examples into an 
  > #   MS (multiple sequences) object
  > ms <- read.ms(seqFile);
  > pwmFile <- "pwm.meme"
  > unzip(exampleArchive, pwmFile)
  > # Read in Position Weight Matrix (PWM) from MEME file from
  > #  the examples into a Matrix object
  > pwm <- read.pwm(pwmFile)
   ----------- FAILURE REPORT -------------- 
   --- failure: the condition has length > 1 ---
   --- srcref --- 
  : 
   --- package (from environment) --- 
  rtfbs
   --- call from context --- 
  label.matrix(x, columnsOnly = TRUE)
   --- call from argument --- 
  if (class(mat) == "list") {
      for (entry in 1:length(mat)) {
          mat[[entry]] <- label.matrix(mat[[entry]], columnsOnly)
      }
  } else if (class(mat) == "matrix") {
      name <- list()
      bases <- list("A", "C", "G", "T")
      if (columnsOnly == FALSE) {
          if (nrow(mat) == 1) {
              name = c("*")
          }
          else {
              for (row in 0:(nrow(mat))) {
                  name[row] <- ""
                  for (s in 1:log(nrow(mat), 4)) {
                    base <- (ceiling(row/(4^(s - 1)))%%4)
                    if (base == 0) 
                      base <- 4
                    name[row] <- paste(bases[base], name[row], 
                      sep = "")
                  }
              }
          }
          rownames(mat) <- name
      }
      colnames(mat) <- bases
  }
   --- R stacktrace ---
  where 1: label.matrix(x, columnsOnly = TRUE)
  where 2: read.pwm(pwmFile)
  
   --- value of length: 2 type: logical ---
  [1] FALSE FALSE
   --- function from context --- 
  function (mat, columnsOnly = FALSE) 
  {
      check.arg(columnsOnly, "columnsOnly", "logical", null.OK = FALSE)
      if (class(mat) == "list") {
          for (entry in 1:length(mat)) {
              mat[[entry]] <- label.matrix(mat[[entry]], columnsOnly)
          }
      }
      else if (class(mat) == "matrix") {
          name <- list()
          bases <- list("A", "C", "G", "T")
          if (columnsOnly == FALSE) {
              if (nrow(mat) == 1) {
                  name = c("*")
              }
              else {
                  for (row in 0:(nrow(mat))) {
                    name[row] <- ""
                    for (s in 1:log(nrow(mat), 4)) {
                      base <- (ceiling(row/(4^(s - 1)))%%4)
                      if (base == 0) 
                        base <- 4
                      name[row] <- paste(bases[base], name[row], 
                        sep = "")
                    }
                  }
              }
              rownames(mat) <- name
          }
          colnames(mat) <- bases
      }
      mat
  }
  <bytecode: 0x36287c8>
  <environment: namespace:rtfbs>
   --- function search by body ---
  Function label.matrix in namespace rtfbs has this body.
   ----------- END OF FAILURE REPORT -------------- 
  Error in if (class(mat) == "list") { : the condition has length > 1
  Calls: read.pwm -> label.matrix
  Execution halted
Running the tests in 'tests/simulate_ms.R' failed.
Complete output:
  > require("rtfbs")
  Loading required package: rtfbs
  > exampleArchive <- system.file("extdata", "NRSF.zip", package="rtfbs")
  > seqFile <- "input.fas"
  > unzip(exampleArchive, seqFile)
  > # Read in FASTA file "input.fas" from the examples into an 
  > #   MS (multiple sequences) object
  > ms <- read.ms(seqFile);
  > # Build a 3rd order Markov Model to represent the sequences
  > #   in the MS object "ms".  The Model will be a list of
  > #   matrices  corrisponding in size to the order of the 
  > #   Markov Model
  > mm <- build.mm(ms, 3);
   ----------- FAILURE REPORT -------------- 
   --- failure: the condition has length > 1 ---
   --- srcref --- 
  : 
   --- package (from environment) --- 
  rtfbs
   --- call from context --- 
  label.matrix(mat[[entry]], columnsOnly)
   --- call from argument --- 
  if (class(mat) == "list") {
      for (entry in 1:length(mat)) {
          mat[[entry]] <- label.matrix(mat[[entry]], columnsOnly)
      }
  } else if (class(mat) == "matrix") {
      name <- list()
      bases <- list("A", "C", "G", "T")
      if (columnsOnly == FALSE) {
          if (nrow(mat) == 1) {
              name = c("*")
          }
          else {
              for (row in 0:(nrow(mat))) {
                  name[row] <- ""
                  for (s in 1:log(nrow(mat), 4)) {
                    base <- (ceiling(row/(4^(s - 1)))%%4)
                    if (base == 0) 
                      base <- 4
                    name[row] <- paste(bases[base], name[row], 
                      sep = "")
                  }
              }
          }
          rownames(mat) <- name
      }
      colnames(mat) <- bases
  }
   --- R stacktrace ---
  where 1: label.matrix(mat[[entry]], columnsOnly)
  where 2: label.matrix(x)
  where 3: build.mm(ms, 3)
  
   --- value of length: 2 type: logical ---
  [1] FALSE FALSE
   --- function from context --- 
  function (mat, columnsOnly = FALSE) 
  {
      check.arg(columnsOnly, "columnsOnly", "logical", null.OK = FALSE)
      if (class(mat) == "list") {
          for (entry in 1:length(mat)) {
              mat[[entry]] <- label.matrix(mat[[entry]], columnsOnly)
          }
      }
      else if (class(mat) == "matrix") {
          name <- list()
          bases <- list("A", "C", "G", "T")
          if (columnsOnly == FALSE) {
              if (nrow(mat) == 1) {
                  name = c("*")
              }
              else {
                  for (row in 0:(nrow(mat))) {
                    name[row] <- ""
                    for (s in 1:log(nrow(mat), 4)) {
                      base <- (ceiling(row/(4^(s - 1)))%%4)
                      if (base == 0) 
                        base <- 4
                      name[row] <- paste(bases[base], name[row], 
                        sep = "")
                    }
                  }
              }
              rownames(mat) <- name
          }
          colnames(mat) <- bases
      }
      mat
  }
  <bytecode: 0x37ed9a8>
  <environment: namespace:rtfbs>
   --- function search by body ---
  Function label.matrix in namespace rtfbs has this body.
   ----------- END OF FAILURE REPORT -------------- 
  Error in if (class(mat) == "list") { : the condition has length > 1
  Calls: build.mm -> label.matrix -> label.matrix
  Execution halted