text: /*      DO NOT EDIT THIS FILE
  *       For FCC testing purposes! */
  
  function objParser(str, init) {
    /* finds objects, arrays, strings, and function arguments
       between parens, because they may contain ',' */
    let openSym = ['[', '{', '"', "'", '('];
    let closeSym = [']', '}', '"', "'", ')'];
    let type, i;
    for(i = (init || 0); i < str.length; i++ ) {
      type = openSym.indexOf(str[i]);
      if( type != -1) { break; }
    }
    if (type == -1) { return null; }
    let open = openSym[type];
    let close = closeSym[type];
    let count = 1, k;
    for(k = i+1; k < str.length; k++) {
      if(open == '"' || open == "'") {
        if(str[k] == close) { count--; }
        if(str[k] == '\\') { k++; }
      } else {
        if(str[k] == open) { count++; }
        if(str[k] == close) { count--; }
      }
      if(count == 0) { break; }
    }
    if(count != 0) { return null; }
    let obj = str.slice(i, k+1);
    return { start : i, end: k, obj: obj };
  }
  
  function replacer(str) { /* replace objects with a symbol ( __#n) */
    let obj;
    let cnt = 0;
    let data = [];
    while(obj = objParser(str)) {
      data[cnt] = obj.obj;
      str = str.substring(0, obj.start) + '__#' + cnt++ + str.substring(obj.end+1)
    }
    return { str : str, dictionary : data };
  }
  
  function splitter(str) { /* split on commas, then restore the objects */
    let strObj = replacer(str);
    let args = strObj.str.split(',');
    args = args.map(function(a){
      let m = a.match(/__#(\d+)/);
      while (m) {
        a = a.replace(/__#(\d+)/, strObj.dictionary[m[1]]);
        m = a.match(/__#(\d+)/);
      }
      return a.trim();
    });
    return args;
  }
  
  function assertionAnalyser(body) {  
    /* // already filtered in the test runner. remove comments.
       body = body.replace(/\/\/.*\n|\/\*.*\*\//g, ''); // get test function body
       body = body.match(/\{\s*([\s\S]*)\}\s*$/)[1]; */
    
    if(!body) { return "invalid assertion"; }
    /* replace assertions bodies, so that they cannot contain the word 'assertion' */
    let cleanedBody = body.match(/(?:browser\s*\.\s*)?assert\s*\.\s*\w*\([\s\S]*\)/);
    if(cleanedBody && Array.isArray(cleanedBody)) {
      body = cleanedBody[0];
    } else { return []; /* No assertions present */ }
    let s = replacer(body); /* split on 'assertion' */
    let splittedAssertions = s.str.split('assert');
    let assertions = splittedAssertions.slice(1);
    let assertionBodies = [];
    let methods = assertions.map(function(a, i){ /* match the METHODS */
      let m = a.match(/^\s*\.\s*(\w+)__#(\d+)/);
      assertionBodies.push(parseInt(m[2]));
      let pre = splittedAssertions[i].match(/browser\s*\.\s*/) ? 'browser.' : '';
      return pre + m[1];
    });
    if(methods.some(function(m){ return !m })) { return "invalid assertion"; }
    /* remove parens from the assertions bodies */
    let bodies = assertionBodies.map(function(b){
      return s.dictionary[b].slice(1,-1).trim();
    });
    assertions = methods.map(function(m, i) {
      return { method: m, args: splitter(bodies[i]) }; 
      /* replace objects, split on ',' ,then restore objects */
    });
    return assertions;
  }
  
  module.exports = assertionAnalyser;
  