diff --git a/src/core/annotation.js b/src/core/annotation.js
index 42f49c2ed..508863acd 100644
--- a/src/core/annotation.js
+++ b/src/core/annotation.js
@@ -68,12 +68,10 @@ AnnotationFactory.prototype = /** @lends AnnotationFactory.prototype */ {
    * @param {Object} ref
    * @param {string} uniquePrefix
    * @param {Object} idCounters
-   * @param {boolean} renderInteractiveForms
    * @returns {Annotation}
    */
   create: function AnnotationFactory_create(xref, ref,
-                                            uniquePrefix, idCounters,
-                                            renderInteractiveForms) {
+                                            uniquePrefix, idCounters) {
     var dict = xref.fetchIfRef(ref);
     if (!isDict(dict)) {
       return;
@@ -92,7 +90,6 @@ AnnotationFactory.prototype = /** @lends AnnotationFactory.prototype */ {
       ref: isRef(ref) ? ref : null,
       subtype: subtype,
       id: id,
-      renderInteractiveForms: renderInteractiveForms,
     };
 
     switch (subtype) {
@@ -417,7 +414,8 @@ var Annotation = (function AnnotationClosure() {
       }.bind(this));
     },
 
-    getOperatorList: function Annotation_getOperatorList(evaluator, task) {
+    getOperatorList: function Annotation_getOperatorList(evaluator, task,
+                                                         renderForms) {
       if (!this.appearance) {
         return Promise.resolve(new OperatorList());
       }
@@ -454,13 +452,13 @@ var Annotation = (function AnnotationClosure() {
   };
 
   Annotation.appendToOperatorList = function Annotation_appendToOperatorList(
-      annotations, opList, partialEvaluator, task, intent) {
+      annotations, opList, partialEvaluator, task, intent, renderForms) {
     var annotationPromises = [];
     for (var i = 0, n = annotations.length; i < n; ++i) {
       if ((intent === 'display' && annotations[i].viewable) ||
           (intent === 'print' && annotations[i].printable)) {
         annotationPromises.push(
-          annotations[i].getOperatorList(partialEvaluator, task));
+          annotations[i].getOperatorList(partialEvaluator, task, renderForms));
       }
     }
     return Promise.all(annotationPromises).then(function(operatorLists) {
@@ -696,8 +694,6 @@ var TextWidgetAnnotation = (function TextWidgetAnnotationClosure() {
   function TextWidgetAnnotation(params) {
     WidgetAnnotation.call(this, params);
 
-    this.renderInteractiveForms = params.renderInteractiveForms;
-
     // Determine the alignment of text in the field.
     var alignment = Util.getInheritableProperty(params.dict, 'Q');
     if (!isInt(alignment) || alignment < 0 || alignment > 2) {
@@ -718,18 +714,20 @@ var TextWidgetAnnotation = (function TextWidgetAnnotationClosure() {
   }
 
   Util.inherit(TextWidgetAnnotation, WidgetAnnotation, {
-    getOperatorList: function TextWidgetAnnotation_getOperatorList(evaluator,
-                                                                   task) {
+    getOperatorList:
+        function TextWidgetAnnotation_getOperatorList(evaluator, task,
+                                                      renderForms) {
       var operatorList = new OperatorList();
 
       // Do not render form elements on the canvas when interactive forms are
       // enabled. The display layer is responsible for rendering them instead.
-      if (this.renderInteractiveForms) {
+      if (renderForms) {
         return Promise.resolve(operatorList);
       }
 
       if (this.appearance) {
-        return Annotation.prototype.getOperatorList.call(this, evaluator, task);
+        return Annotation.prototype.getOperatorList.call(this, evaluator, task,
+                                                         renderForms);
       }
 
       // Even if there is an appearance stream, ignore it. This is the
diff --git a/src/core/document.js b/src/core/document.js
index 0d5535385..710597a4d 100644
--- a/src/core/document.js
+++ b/src/core/document.js
@@ -246,8 +246,6 @@ var Page = (function PageClosure() {
           });
       });
 
-      this.renderInteractiveForms = renderInteractiveForms;
-
       var annotationsPromise = pdfManager.ensure(this, 'annotations');
       return Promise.all([pageListPromise, annotationsPromise]).then(
           function(datas) {
@@ -260,7 +258,8 @@ var Page = (function PageClosure() {
         }
 
         var annotationsReadyPromise = Annotation.appendToOperatorList(
-          annotations, pageOpList, partialEvaluator, task, intent);
+          annotations, pageOpList, partialEvaluator, task, intent,
+          renderInteractiveForms);
         return annotationsReadyPromise.then(function () {
           pageOpList.flush(true);
           return pageOpList;
@@ -331,8 +330,7 @@ var Page = (function PageClosure() {
         var annotationRef = annotationRefs[i];
         var annotation = annotationFactory.create(this.xref, annotationRef,
                                                   this.uniquePrefix,
-                                                  this.idCounters,
-                                                  this.renderInteractiveForms);
+                                                  this.idCounters);
         if (annotation) {
           annotations.push(annotation);
         }
diff --git a/src/display/annotation_layer.js b/src/display/annotation_layer.js
index 5324476a8..3fc536d18 100644
--- a/src/display/annotation_layer.js
+++ b/src/display/annotation_layer.js
@@ -448,14 +448,18 @@ var TextWidgetAnnotationElement = (
 
       var element = null;
       if (this.renderInteractiveForms) {
+        // NOTE: We cannot set the values using `element.value` below, since it
+        //       prevents the AnnotationLayer rasterizer in `test/driver.js`
+        //       from parsing the elements correctly for the reference tests.
         if (this.data.multiLine) {
           element = document.createElement('textarea');
+          element.textContent = this.data.fieldValue;
         } else {
           element = document.createElement('input');
           element.type = 'text';
+          element.setAttribute('value', this.data.fieldValue);
         }
 
-        element.value = this.data.fieldValue;
         element.disabled = this.data.readOnly;
 
         if (this.data.maxLen !== null) {
diff --git a/test/driver.js b/test/driver.js
index a15cc8bf7..b1ab04a3e 100644
--- a/test/driver.js
+++ b/test/driver.js
@@ -459,6 +459,9 @@ var Driver = (function DriverClosure() {
             self.canvas.height = viewport.height;
             self._clearCanvas();
 
+            // Initialize various `eq` test subtypes, see comment below.
+            var renderAnnotations = false, renderForms = false;
+
             var textLayerCanvas, annotationLayerCanvas;
             var initPromise;
             if (task.type === 'text') {
@@ -483,9 +486,13 @@ var Driver = (function DriverClosure() {
               });
             } else {
               textLayerCanvas = null;
+              // We fetch the `eq` specific test subtypes here, to avoid
+              // accidentally changing the behaviour for other types of tests.
+              renderAnnotations = !!task.annotations;
+              renderForms = !!task.forms;
 
               // Render the annotation layer if necessary.
-              if (task.annotations || task.forms) {
+              if (renderAnnotations || renderForms) {
                 // Create a dummy canvas for the drawing operations.
                 annotationLayerCanvas = self.annotationLayerCanvas;
                 if (!annotationLayerCanvas) {
@@ -503,10 +510,9 @@ var Driver = (function DriverClosure() {
                 initPromise =
                   page.getAnnotations({ intent: 'display' }).then(
                     function(annotations) {
-                      var forms = task.forms || false;
                       return rasterizeAnnotationLayer(annotationLayerContext,
                                                       viewport, annotations,
-                                                      page, forms);
+                                                      page, renderForms);
                   });
               } else {
                 annotationLayerCanvas = null;
@@ -516,7 +522,8 @@ var Driver = (function DriverClosure() {
 
             var renderContext = {
               canvasContext: ctx,
-              viewport: viewport
+              viewport: viewport,
+              renderInteractiveForms: renderForms,
             };
             var completeRender = (function(error) {
               // if text layer is present, compose it on top of the page