How to use

operator

function

in

ArrayExpression

UnaryExpression (node) {
   if (node.operator !== '-') {
    return
   }
   const line = node.loc.start.line
   const lineContent = lines[line - 1]

   const mutantLineContent = lineContent.substr(0, node.loc.start.column) +
    lineContent.substr(node.loc.start.column + 1)

   const mutantId = ++mutodeInstance.mutants
   const diff = lineDiff(lineContent, mutantLineContent)
   const log = `MUTANT ${mutantId}:\tINM Line ${line}:\t${diff}...`
   debug(log)
   mutodeInstance.mutantLog(`MUTANT ${mutantId}:\tINM ${filePath} Line ${line}:\t\`${lineContent.trim()}\` > \`${mutantLineContent.trim()}'\``)
   const linesCopy = lines.slice()
   linesCopy[line - 1] = mutantLineContent
   const contentToWrite = linesCopy.join('\n')
   queue.push(mutantRunner({ mutodeInstance, filePath, contentToWrite, log }))
  }

BinaryExpression (node) {
   for (const pair of operators) {
    if (node.operator !== pair[0] || node.left.loc.end - node.right.loc.start > 5) {
     continue
    }
    const line = node.loc.start.line
    const lineContent = lines[line - 1]

    const mutantLineContent = lineContent.substr(0, node.left.loc.end.column) +
     lineContent.substr(node.left.loc.end.column, node.right.loc.start.column - node.left.loc.end.column).replace(pair[0], pair[1]) +
     lineContent.substr(node.right.loc.start.column)

    const mutantId = ++mutodeInstance.mutants
    const diff = lineDiff(lineContent, mutantLineContent)
    const log = `MUTANT ${mutantId}:\tMM Line ${line}:\t${diff}`
    debug(log)
    mutodeInstance.mutantLog(`MUTANT ${mutantId}:\tMM ${filePath} Line ${line}:\t\`${lineContent.trim()}\` > \`${mutantLineContent.trim()}'\``)
    const linesCopy = lines.slice()
    linesCopy[line - 1] = mutantLineContent
    const contentToWrite = linesCopy.join('\n')
    queue.push(mutantRunner({ mutodeInstance, filePath, contentToWrite, log }))
   }
  }

BinaryExpression (node) {
   for (const pair of operators) {
    if (node.operator !== pair[0]) {
     continue
    }
    const line = node.loc.start.line
    const lineContent = lines[line - 1]

    const mutantLineContent = lineContent.substr(0, node.loc.start.column) +
     lineContent.substr(node.loc.start.column, node.loc.end.column - node.loc.start.column).replace(pair[0], pair[1]) +
     lineContent.substr(node.loc.end.column)

    const mutantId = ++mutodeInstance.mutants
    const diff = lineDiff(lineContent, mutantLineContent)
    const log = `MUTANT ${mutantId}:\tCBM Line ${line}:\t${diff}`
    debug(log)
    mutodeInstance.mutantLog(`MUTANT ${mutantId}:\tCBM ${filePath} Line ${line}:\t\`${lineContent.trim()}\` > \`${mutantLineContent.trim()}'\``)
    const linesCopy = lines.slice()
    linesCopy[line - 1] = mutantLineContent
    const contentToWrite = linesCopy.join('\n')
    queue.push(mutantRunner({ mutodeInstance, filePath, contentToWrite, log }))
   }
  }

BinaryExpression (node) {
   for (const operator of operators) {
    if (node.operator !== operator) {
     continue
    }
    const line = node.loc.start.line
    const lineContent = lines[line - 1]

    for (const replacement of ['true', 'false']) {
     const mutantLineContent = lineContent.substr(0, node.loc.start.column) +
      replacement +
      lineContent.substr(node.loc.end.column)

     const mutantId = ++mutodeInstance.mutants
     const diff = lineDiff(lineContent, mutantLineContent)
     const log = `MUTANT ${mutantId}:\tRCM Line ${line}:\t${diff}`
     debug(log)
     mutodeInstance.mutantLog(`MUTANT ${mutantId}:\tRCM ${filePath} Line ${line}:\t\`${lineContent.trim()}\` > \`${mutantLineContent.trim()}'\``)
     const linesCopy = lines.slice()
     linesCopy[line - 1] = mutantLineContent
     const contentToWrite = linesCopy.join('\n')
     queue.push(mutantRunner({ mutodeInstance, filePath, contentToWrite, log }))
    }
   }
  }

UpdateExpression (node) {
   for (const pair of operators) {
    if (node.operator !== pair[0]) {
     continue
    }
    const line = node.loc.start.line
    const lineContent = lines[line - 1]

    const mutantLineContent = lineContent.substr(0, node.loc.start.column) +
     lineContent.substr(node.loc.start.column, node.loc.end.column - node.loc.start.column).replace(pair[0], pair[1]) +
     lineContent.substr(node.loc.end.column)

    const mutantId = ++mutodeInstance.mutants
    const diff = lineDiff(lineContent, mutantLineContent)
    const log = `MUTANT ${mutantId}:\tIM Line ${line}:\t${diff}...`
    debug(log)
    mutodeInstance.mutantLog(`MUTANT ${mutantId}:\tIM ${filePath} Line ${line}:\t\`${lineContent.trim()}\` > \`${mutantLineContent.trim()}'\``)
    const linesCopy = lines.slice()
    linesCopy[line - 1] = mutantLineContent
    const contentToWrite = linesCopy.join('\n')
    queue.push(mutantRunner({ mutodeInstance, filePath, contentToWrite, log }))
   }
  }

BinaryExpression (node) {
   for (const pair of operators) {
    if (node.operator !== pair[0]) {
     continue
    }
    const line = node.loc.start.line
    const lineContent = lines[line - 1]

    const mutantLineContent = lineContent.substr(0, node.loc.start.column) +
     lineContent.substr(node.loc.start.column, node.loc.end.column - node.loc.start.column).replace(pair[0], pair[1]) +
     lineContent.substr(node.loc.end.column)

    const mutantId = ++mutodeInstance.mutants
    const diff = lineDiff(lineContent, mutantLineContent)
    const log = `MUTANT ${mutantId}:\tNCM Line ${line}:\t${diff}`
    debug(log)
    mutodeInstance.mutantLog(`MUTANT ${mutantId}:\tNCM ${filePath} Line ${line}:\t\`${lineContent.trim()}\` > \`${mutantLineContent.trim()}'\``)
    const linesCopy = lines.slice()
    linesCopy[line - 1] = mutantLineContent
    const contentToWrite = linesCopy.join('\n')
    queue.push(mutantRunner({ mutodeInstance, filePath, contentToWrite, log }))
   }
  }