--- a/testing/modules/CoverageUtils.jsm
+++ b/testing/modules/CoverageUtils.jsm
@@ -88,89 +88,64 @@ CoverageCollector.prototype._getLinesCov
         this._allCoverage[scriptName][key] = currentCoverage[scriptName][key];
       }
     }
   }
 
   return coveredLines;
 }
 
-
 CoverageCollector.prototype._getUncoveredLines = function() {
   let uncoveredLines = {};
-  let currentUncovered = {};
-  let tempCovered = {};
+  let tempUncov = {};
   this._scripts.forEach(s => {
-    let cov = s.getOffsetsCoverage();
     let scriptName = s.url;
-      
-    if(!currentUncovered[scriptName]){
-      currentUncovered[scriptName] = new Set();
-    }
-    //Get the lines not covered within the script that does not have coverage
-    if (!cov){
-      cov = s.getAllColumnOffsets();
-      cov.forEach(notCovered => {
-        let {lineNumber, columnnumber, offset} = notCovered;
-        if(!currentUncovered[scriptName][lineNumber]){
-          currentUncovered[scriptName][lineNumber] = 0;
-        }
-      });
-      return;  
-    }
-    if (!this._allCoverage[scriptName]) {
-      this._allCoverage[scriptName] = {};
+    let cov2 = s.getAllOffsets();
+
+    // Initialized to first script as it has room for all lines
+    if(!tempUncov[scriptName]){
+        tempUncov[scriptName] = cov2;
     }
-    if (!tempCovered[scriptName]){
-        tempCovered[scriptName] = new Set();
-    }
-      
-    //Get the lines not covered within a script which has coverage
-    cov.forEach(covered => {
-      let {lineNumber, columnnumber, offset, count} = covered; 
-      if (!count){
-        if (!currentUncovered[scriptName][lineNumber]){
-          //If we haven't covered this line before
-          if (!tempCovered[scriptName][lineNumber]){ 
-            currentUncovered[scriptName][lineNumber] = count;
-          }
-        }
+
+    // Get all lines in the script
+    cov2.forEach( function(element, index, array) {
+      if (!element){
+        return;
       }
-      else{
-        //tempCovered is obtained here to determine if a line was covered in a previous run
-        if (!tempCovered[scriptName][lineNumber]){
-          tempCovered[scriptName][lineNumber] = count;
-        }
-        else{
-          tempCovered[scriptName][lineNumber] += count;
-        }
-        //If the current line is counted and in the currently uncovered lines
-        if (currentUncovered[scriptName][lineNumber] < currentUncovered[scriptName][lineNumber]+count){
-          currentUncovered[scriptName][lineNumber] += count;    
-        }
+      if(!tempUncov[scriptName][index]){
+        tempUncov[scriptName][index] = 1;
       }
     });
   });
-  //Gather all lines uncovered based on whether they were counted or not.
-  for (let scriptName in currentUncovered){
-    for (let key in currentUncovered[scriptName]){
-      if (currentUncovered[scriptName][key] === 0){
-        if (!uncoveredLines[scriptName]){
-          uncoveredLines[scriptName] = new Set();
-        }
-        if (!uncoveredLines[scriptName][key]){
-          uncoveredLines[scriptName][key] = key;
+
+  // For all covered lines, set their value to -1
+  for (let scriptName in this._allCoverage){
+    for(let key in this._allCoverage[scriptName]){
+      let [lineNumber, columnNumber, offset] = key.split('#');
+      tempUncov[scriptName][lineNumber] = -1;
+    }
+  }
+
+  // Gather all lines which are not null
+  for (let scriptName in tempUncov){
+    for (let line in tempUncov[scriptName]){
+      if (!uncoveredLines[scriptName]){
+        uncoveredLines[scriptName] = new Set();
+      }
+      if (tempUncov[scriptName][line] != -1){
+        if (tempUncov[scriptName][line]){
+          uncoveredLines[scriptName].add(parseInt(line,10));
         }
       }
-    }                                             
+    }
   }
+
   return uncoveredLines;
 }
 
-
 /**
 * Returns an array containing keys in the form "lineNumber#methodName" that
 * has each line number associated to a method. If the method is found to have
 * an undefined name, we give it a name "undefined_integer" and every time we find
 * a new undefined method, we increment the integer. There is the possibility that
 * multiple functions can be caught on the same line. If a method has not been covered
 * at all, we use lineNumber == '-1' to designate that it will not have any lines covered.
 * This is needed to be able to have an empty covered array for the uncovered method.