diff --git a/examples/example.js b/examples/example.js
index 152ba44a..cf083ef3 100644
--- a/examples/example.js
+++ b/examples/example.js
@@ -2,27 +2,29 @@ var fs = require('fs'),
   util = require('util'),
   path = require('path'),
   xml = fs.readFileSync(path.join(__dirname, 'test.xml'), 'utf8'),
-  sax = require('../lib/sax'),
-  strict = sax.parser(true),
-  loose = sax.parser(false, {trim: true}),
+  saxes = require('../lib/saxes'),
+  parser = saxes.parser(),
   inspector = function (ev) { return function (data) {
-      console.error('%s %s %j', this.line + ':' + this.column, ev, data)
-    }}
+    console.error('%s %s %j', this.line + ':' + this.column, ev, data)
+    if (ev === "error") {
+      parser.resume()
+    }
+  }}
 
-sax.EVENTS.forEach(function (ev) {
-  loose['on' + ev] = inspector(ev)
+saxes.EVENTS.forEach(function (ev) {
+  parser['on' + ev] = inspector(ev)
 })
-loose.onend = function () {
+parser.onend = function () {
   console.error('end')
-  console.error(loose)
+  console.error(parser)
 }
 
 // do this in random bits at a time to verify that it works.
 (function () {
   if (xml) {
     var c = Math.ceil(Math.random() * 1000)
-    loose.write(xml.substr(0, c))
+    parser.write(xml.substr(0, c))
     xml = xml.substr(c)
     process.nextTick(arguments.callee)
-  } else loose.close()
-})()
+  } else parser.close()
+}())
diff --git a/lib/saxes.js b/lib/saxes.js
index 795d607e..8fe80908 100644
--- a/lib/saxes.js
+++ b/lib/saxes.js
@@ -1,5 +1,5 @@
 ;(function (sax) { // wrapper for non-node envs
-  sax.parser = function (strict, opt) { return new SAXParser(strict, opt) }
+  sax.parser = function (opt) { return new SAXParser(opt) }
   sax.SAXParser = SAXParser
   sax.SAXStream = SAXStream
   sax.createStream = createStream
@@ -18,7 +18,7 @@
   var buffers = [
     'comment', 'sgmlDecl', 'textNode', 'tagName', 'doctype',
     'procInstName', 'procInstBody', 'entity', 'attribName',
-    'attribValue', 'cdata', 'script'
+    'attribValue', 'cdata'
   ]
 
   sax.EVENTS = [
@@ -37,14 +37,13 @@
     'error',
     'end',
     'ready',
-    'script',
     'opennamespace',
     'closenamespace'
   ]
 
-  function SAXParser (strict, opt) {
+  function SAXParser (opt) {
     if (!(this instanceof SAXParser)) {
-      return new SAXParser(strict, opt)
+      return new SAXParser(opt)
     }
 
     var parser = this
@@ -57,8 +56,6 @@
     parser.tags = []
     parser.closed = parser.closedRoot = parser.sawRoot = false
     parser.tag = parser.error = null
-    parser.strict = !!strict
-    parser.noscript = !!(strict || parser.opt.noscript)
     parser.state = S.BEGIN
     parser.strictEntities = parser.opt.strictEntities
     parser.ENTITIES = parser.strictEntities ? Object.create(sax.XML_ENTITIES) : Object.create(sax.ENTITIES)
@@ -116,11 +113,6 @@
             parser.cdata = ''
             break
 
-          case 'script':
-            emitNode(parser, 'onscript', parser.script)
-            parser.script = ''
-            break
-
           default:
             error(parser, 'Max buffer length exceeded: ' + buffers[i])
         }
@@ -144,10 +136,6 @@
       emitNode(parser, 'oncdata', parser.cdata)
       parser.cdata = ''
     }
-    if (parser.script !== '') {
-      emitNode(parser, 'onscript', parser.script)
-      parser.script = ''
-    }
   }
 
   SAXParser.prototype = {
@@ -169,18 +157,18 @@
     return ev !== 'error' && ev !== 'end'
   })
 
-  function createStream (strict, opt) {
-    return new SAXStream(strict, opt)
+  function createStream (opt) {
+    return new SAXStream(opt)
   }
 
-  function SAXStream (strict, opt) {
+  function SAXStream (opt) {
     if (!(this instanceof SAXStream)) {
-      return new SAXStream(strict, opt)
+      return new SAXStream(opt)
     }
 
     Stream.apply(this)
 
-    this._parser = new SAXParser(strict, opt)
+    this._parser = new SAXParser(opt)
     this.writable = true
     this.readable = true
 
@@ -339,8 +327,6 @@
     ATTRIB_VALUE_ENTITY_U: S++, // <foo bar=&quot
     CLOSE_TAG: S++, // </a
     CLOSE_TAG_SAW_WHITE: S++, // </a   >
-    SCRIPT: S++, // <script> ...
-    SCRIPT_ENDING: S++ // <script> ... <
   }
 
   sax.XML_ENTITIES = {
@@ -655,7 +641,7 @@
   }
 
   function end (parser) {
-    if (parser.sawRoot && !parser.closedRoot) strictFail(parser, 'Unclosed root tag')
+    if (parser.sawRoot && !parser.closedRoot) fail(parser, 'Unclosed root tag')
     if ((parser.state !== S.BEGIN) &&
       (parser.state !== S.BEGIN_WHITESPACE) &&
       (parser.state !== S.TEXT)) {
@@ -665,21 +651,18 @@
     parser.c = ''
     parser.closed = true
     emit(parser, 'onend')
-    SAXParser.call(parser, parser.strict, parser.opt)
+    SAXParser.call(parser, parser.opt)
     return parser
   }
 
-  function strictFail (parser, message) {
+  function fail (parser, message) {
     if (typeof parser !== 'object' || !(parser instanceof SAXParser)) {
-      throw new Error('bad call to strictFail')
-    }
-    if (parser.strict) {
-      error(parser, message)
+      throw new Error('bad call to fail')
     }
+    error(parser, message)
   }
 
   function newTag (parser) {
-    if (!parser.strict) parser.tagName = parser.tagName[parser.looseCase]()
     var parent = parser.tags[parser.tags.length - 1] || parser
     var tag = parser.tag = { name: parser.tagName, attributes: {} }
 
@@ -707,10 +690,6 @@
   }
 
   function attrib (parser) {
-    if (!parser.strict) {
-      parser.attribName = parser.attribName[parser.looseCase]()
-    }
-
     if (parser.attribList.indexOf(parser.attribName) !== -1 ||
       parser.tag.attributes.hasOwnProperty(parser.attribName)) {
       parser.attribName = parser.attribValue = ''
@@ -725,11 +704,11 @@
       if (prefix === 'xmlns') {
         // namespace binding attribute. push the binding into scope
         if (local === 'xml' && parser.attribValue !== XML_NAMESPACE) {
-          strictFail(parser,
+          fail(parser,
             'xml: prefix must be bound to ' + XML_NAMESPACE + '\n' +
             'Actual: ' + parser.attribValue)
         } else if (local === 'xmlns' && parser.attribValue !== XMLNS_NAMESPACE) {
-          strictFail(parser,
+          fail(parser,
             'xmlns: prefix must be bound to ' + XMLNS_NAMESPACE + '\n' +
             'Actual: ' + parser.attribValue)
         } else {
@@ -770,7 +749,7 @@
       tag.uri = tag.ns[qn.prefix] || ''
 
       if (tag.prefix && !tag.uri) {
-        strictFail(parser, 'Unbound namespace prefix: ' +
+        fail(parser, 'Unbound namespace prefix: ' +
           JSON.stringify(parser.tagName))
         tag.uri = qn.prefix
       }
@@ -807,7 +786,7 @@
         // if there's any attributes with an undefined namespace,
         // then fail on them now.
         if (prefix && prefix !== 'xmlns' && !uri) {
-          strictFail(parser, 'Unbound namespace prefix: ' +
+          fail(parser, 'Unbound namespace prefix: ' +
             JSON.stringify(prefix))
           a.uri = prefix
         }
@@ -824,12 +803,7 @@
     parser.tags.push(parser.tag)
     emitNode(parser, 'onopentag', parser.tag)
     if (!selfClosing) {
-      // special case for <script> in non-strict mode.
-      if (!parser.noscript && parser.tagName.toLowerCase() === 'script') {
-        parser.state = S.SCRIPT
-      } else {
-        parser.state = S.TEXT
-      }
+      parser.state = S.TEXT
       parser.tag = null
       parser.tagName = ''
     }
@@ -839,44 +813,28 @@
 
   function closeTag (parser) {
     if (!parser.tagName) {
-      strictFail(parser, 'Weird empty close tag.')
+      fail(parser, 'Weird empty close tag.')
       parser.textNode += '</>'
       parser.state = S.TEXT
       return
     }
 
-    if (parser.script) {
-      if (parser.tagName !== 'script') {
-        parser.script += '</' + parser.tagName + '>'
-        parser.tagName = ''
-        parser.state = S.SCRIPT
-        return
-      }
-      emitNode(parser, 'onscript', parser.script)
-      parser.script = ''
-    }
-
     // first make sure that the closing tag actually exists.
     // <a><b></c></b></a> will close everything, otherwise.
     var t = parser.tags.length
     var tagName = parser.tagName
-    if (!parser.strict) {
-      tagName = tagName[parser.looseCase]()
-    }
     var closeTo = tagName
     while (t--) {
       var close = parser.tags[t]
       if (close.name !== closeTo) {
-        // fail the first time in strict mode
-        strictFail(parser, 'Unexpected close tag')
+        fail(parser, 'Unexpected close tag')
       } else {
         break
       }
     }
 
-    // didn't find it.  we already failed for strict, so just abort.
     if (t < 0) {
-      strictFail(parser, 'Unmatched closing tag: ' + parser.tagName)
+      fail(parser, 'Unmatched closing tag: ' + parser.tagName)
       parser.textNode += '</' + parser.tagName + '>'
       parser.state = S.TEXT
       return
@@ -934,7 +892,7 @@
     }
     entity = entity.replace(/^0+/, '')
     if (isNaN(num) || numStr.toLowerCase() !== entity) {
-      strictFail(parser, 'Invalid character entity')
+      fail(parser, 'Invalid character entity')
       return '&' + parser.entity + ';'
     }
 
@@ -948,7 +906,7 @@
     } else if (!isWhitespace(c)) {
       // have to process this as a text node.
       // weird, but happens.
-      strictFail(parser, 'Non-whitespace before first tag.')
+      fail(parser, 'Non-whitespace before first tag.')
       parser.textNode = c
       parser.state = S.TEXT
     }
@@ -1027,12 +985,12 @@
             }
             parser.textNode += chunk.substring(starti, i - 1)
           }
-          if (c === '<' && !(parser.sawRoot && parser.closedRoot && !parser.strict)) {
+          if (c === '<') {
             parser.state = S.OPEN_WAKA
             parser.startTagPosition = parser.position
           } else {
             if (!isWhitespace(c) && (!parser.sawRoot || parser.closedRoot)) {
-              strictFail(parser, 'Text data outside of root node.')
+              fail(parser, 'Text data outside of root node.')
             }
             if (c === '&') {
               parser.state = S.TEXT_ENTITY
@@ -1042,24 +1000,6 @@
           }
           continue
 
-        case S.SCRIPT:
-          // only non-strict
-          if (c === '<') {
-            parser.state = S.SCRIPT_ENDING
-          } else {
-            parser.script += c
-          }
-          continue
-
-        case S.SCRIPT_ENDING:
-          if (c === '/') {
-            parser.state = S.CLOSE_TAG
-          } else {
-            parser.script += '<' + c
-            parser.state = S.SCRIPT
-          }
-          continue
-
         case S.OPEN_WAKA:
           // either a /, ?, !, or text is coming next.
           if (c === '!') {
@@ -1077,7 +1017,7 @@
             parser.state = S.PROC_INST
             parser.procInstName = parser.procInstBody = ''
           } else {
-            strictFail(parser, 'Unencoded <')
+            fail(parser, 'Unencoded <')
             // if there was some whitespace, then add that in.
             if (parser.startTagPosition + 1 < parser.position) {
               var pad = parser.position - parser.startTagPosition
@@ -1101,7 +1041,7 @@
           } else if ((parser.sgmlDecl + c).toUpperCase() === DOCTYPE) {
             parser.state = S.DOCTYPE
             if (parser.doctype || parser.sawRoot) {
-              strictFail(parser,
+              fail(parser,
                 'Inappropriately located doctype declaration')
             }
             parser.doctype = ''
@@ -1192,9 +1132,9 @@
 
         case S.COMMENT_ENDED:
           if (c !== '>') {
-            strictFail(parser, 'Malformed comment')
-            // allow <!-- blah -- bloo --> in non-strict mode,
-            // which is a comment of " blah -- bloo "
+            fail(parser, 'Malformed comment')
+            // <!-- blah -- bloo --> will be recorded as
+            // a comment of " blah -- bloo "
             parser.comment += '--' + c
             parser.state = S.COMMENT
           } else {
@@ -1280,7 +1220,7 @@
               parser.state = S.OPEN_TAG_SLASH
             } else {
               if (!isWhitespace(c)) {
-                strictFail(parser, 'Invalid character in tag name')
+                fail(parser, 'Invalid character in tag name')
               }
               parser.state = S.ATTRIB
             }
@@ -1292,7 +1232,7 @@
             openTag(parser, true)
             closeTag(parser)
           } else {
-            strictFail(parser, 'Forward-slash in opening tag not followed by >')
+            fail(parser, 'Forward-slash in opening tag not followed by >')
             parser.state = S.ATTRIB
           }
           continue
@@ -1310,7 +1250,7 @@
             parser.attribValue = ''
             parser.state = S.ATTRIB_NAME
           } else {
-            strictFail(parser, 'Invalid attribute name')
+            fail(parser, 'Invalid attribute name')
           }
           continue
 
@@ -1318,7 +1258,7 @@
           if (c === '=') {
             parser.state = S.ATTRIB_VALUE
           } else if (c === '>') {
-            strictFail(parser, 'Attribute without value')
+            fail(parser, 'Attribute without value')
             parser.attribValue = parser.attribName
             attrib(parser)
             openTag(parser)
@@ -1327,7 +1267,7 @@
           } else if (isMatch(nameBody, c)) {
             parser.attribName += c
           } else {
-            strictFail(parser, 'Invalid attribute name')
+            fail(parser, 'Invalid attribute name')
           }
           continue
 
@@ -1337,7 +1277,7 @@
           } else if (isWhitespace(c)) {
             continue
           } else {
-            strictFail(parser, 'Attribute without value')
+            fail(parser, 'Attribute without value')
             parser.tag.attributes[parser.attribName] = ''
             parser.attribValue = ''
             emitNode(parser, 'onattribute', {
@@ -1351,7 +1291,7 @@
               parser.attribName = c
               parser.state = S.ATTRIB_NAME
             } else {
-              strictFail(parser, 'Invalid attribute name')
+              fail(parser, 'Invalid attribute name')
               parser.state = S.ATTRIB
             }
           }
@@ -1364,7 +1304,7 @@
             parser.q = c
             parser.state = S.ATTRIB_VALUE_QUOTED
           } else {
-            strictFail(parser, 'Unquoted attribute value')
+            fail(parser, 'Unquoted attribute value')
             parser.state = S.ATTRIB_VALUE_UNQUOTED
             parser.attribValue = c
           }
@@ -1392,12 +1332,12 @@
           } else if (c === '/') {
             parser.state = S.OPEN_TAG_SLASH
           } else if (isMatch(nameStart, c)) {
-            strictFail(parser, 'No whitespace between attributes')
+            fail(parser, 'No whitespace between attributes')
             parser.attribName = c
             parser.attribValue = ''
             parser.state = S.ATTRIB_NAME
           } else {
-            strictFail(parser, 'Invalid attribute name')
+            fail(parser, 'Invalid attribute name')
           }
           continue
 
@@ -1423,12 +1363,7 @@
             if (isWhitespace(c)) {
               continue
             } else if (notMatch(nameStart, c)) {
-              if (parser.script) {
-                parser.script += '</' + c
-                parser.state = S.SCRIPT
-              } else {
-                strictFail(parser, 'Invalid tagname in closing tag.')
-              }
+              fail(parser, 'Invalid tagname in closing tag.')
             } else {
               parser.tagName = c
             }
@@ -1436,13 +1371,9 @@
             closeTag(parser)
           } else if (isMatch(nameBody, c)) {
             parser.tagName += c
-          } else if (parser.script) {
-            parser.script += '</' + parser.tagName
-            parser.tagName = ''
-            parser.state = S.SCRIPT
           } else {
             if (!isWhitespace(c)) {
-              strictFail(parser, 'Invalid tagname in closing tag')
+              fail(parser, 'Invalid tagname in closing tag')
             }
             parser.state = S.CLOSE_TAG_SAW_WHITE
           }
@@ -1455,7 +1386,7 @@
           if (c === '>') {
             closeTag(parser)
           } else {
-            strictFail(parser, 'Invalid characters in closing tag')
+            fail(parser, 'Invalid characters in closing tag')
           }
           continue
 
@@ -1488,7 +1419,7 @@
           } else if (isMatch(parser.entity.length ? entityBody : entityStart, c)) {
             parser.entity += c
           } else {
-            strictFail(parser, 'Invalid character in entity name')
+            fail(parser, 'Invalid character in entity name')
             parser[buffer] += '&' + parser.entity + c
             parser.entity = ''
             parser.state = returnState
diff --git a/test/attribute-name.js b/test/attribute-name.js
index 70376895..ecb85b7e 100644
--- a/test/attribute-name.js
+++ b/test/attribute-name.js
@@ -37,7 +37,6 @@ require(__dirname).test({
       'root'
     ]
   ],
-  strict: true,
   opt: {
     xmlns: true
   }
diff --git a/test/attribute-no-space.js b/test/attribute-no-space.js
index 90aec90e..9a2441e5 100644
--- a/test/attribute-no-space.js
+++ b/test/attribute-no-space.js
@@ -1,18 +1,4 @@
-// non-strict: no error
-require(__dirname).test({
-  xml: '<root attr1="first"attr2="second"/>',
-  expect: [
-    [ 'opentagstart', { name: 'root', attributes: {} } ],
-    [ 'attribute', { name: 'attr1', value: 'first' } ],
-    [ 'attribute', { name: 'attr2', value: 'second' } ],
-    [ 'opentag', { name: 'root', attributes: { attr1: 'first', attr2: 'second' }, isSelfClosing: true } ],
-    [ 'closetag', 'root' ]
-  ],
-  strict: false,
-  opt: { lowercase: true }
-})
-
-// strict: should give an error, but still parse
+// should give an error, but still parse
 require(__dirname).test({
   xml: '<root attr1="first"attr2="second"/>',
   expect: [
@@ -23,12 +9,10 @@ require(__dirname).test({
     [ 'opentag', { name: 'root', attributes: { attr1: 'first', attr2: 'second' }, isSelfClosing: true } ],
     [ 'closetag', 'root' ]
   ],
-  strict: true,
   opt: { }
-}
-)
+})
 
-// strict: other cases should still pass
+// other cases should still pass
 require(__dirname).test({
   xml: '<root attr1="first" attr2="second"/>',
   expect: [
@@ -38,11 +22,10 @@ require(__dirname).test({
     [ 'opentag', { name: 'root', attributes: { attr1: 'first', attr2: 'second' }, isSelfClosing: true } ],
     [ 'closetag', 'root' ]
   ],
-  strict: true,
   opt: { }
 })
 
-// strict: other cases should still pass
+// other cases should still pass
 require(__dirname).test({
   xml: '<root attr1="first"\nattr2="second"/>',
   expect: [
@@ -52,11 +35,10 @@ require(__dirname).test({
     [ 'opentag', { name: 'root', attributes: { attr1: 'first', attr2: 'second' }, isSelfClosing: true } ],
     [ 'closetag', 'root' ]
   ],
-  strict: true,
   opt: { }
 })
 
-// strict: other cases should still pass
+// other cases should still pass
 require(__dirname).test({
   xml: '<root attr1="first"  attr2="second"/>',
   expect: [
@@ -66,6 +48,5 @@ require(__dirname).test({
     [ 'opentag', { name: 'root', attributes: { attr1: 'first', attr2: 'second' }, isSelfClosing: true } ],
     [ 'closetag', 'root' ]
   ],
-  strict: true,
   opt: { }
 })
diff --git a/test/attribute-unquoted.js b/test/attribute-unquoted.js
index 40ca82bb..ace9a667 100644
--- a/test/attribute-unquoted.js
+++ b/test/attribute-unquoted.js
@@ -1,35 +1,38 @@
 require(__dirname).test({
   expect: [
-    [ 'opentagstart', { name: 'ROOT', attributes: {}, ns: {} } ],
+    [ 'opentagstart', { name: 'root', attributes: {}, ns: {} } ],
+    [ 'error', "Unquoted attribute value\n\
+Line: 0\n\
+Column: 14\n\
+Char: 1" ],
     [ 'attribute', {
-      name: 'LENGTH',
+      name: 'length',
       value: '12345',
       prefix: '',
-      local: 'LENGTH',
+      local: 'length',
       uri: ''
-    } ],
+    }],
     [ 'opentag', {
-      name: 'ROOT',
+      name: 'root',
       attributes: {
-        LENGTH: {
-          name: 'LENGTH',
+        length: {
+          name: 'length',
           value: '12345',
           prefix: '',
-          local: 'LENGTH',
+          local: 'length',
           uri: ''
         }
       },
       ns: {},
       prefix: '',
-      local: 'ROOT',
+      local: 'root',
       uri: '',
       isSelfClosing: false
     } ],
-    [ 'closetag', 'ROOT' ],
+    [ 'closetag', 'root' ],
     [ 'end' ],
     [ 'ready' ]
   ],
-  strict: false,
   opt: {
     xmlns: true
   }
diff --git a/test/bom.js b/test/bom.js
index 79d39091..9fb6de7f 100644
--- a/test/bom.js
+++ b/test/bom.js
@@ -30,7 +30,6 @@ require(__dirname).test({
     ['opentag', {'name': 'P', attributes: {}, isSelfClosing: false}],
     ['closetag', 'P']
   ],
-  strict: true
 })
 
 // There is only one BOM allowed at the start
@@ -43,5 +42,4 @@ require(__dirname).test({
     ['opentag', {'name': 'P', attributes: {}, isSelfClosing: false}],
     ['closetag', 'P']
   ],
-  strict: true
 })
diff --git a/test/buffer-overrun.js b/test/buffer-overrun.js
index 65693a0a..0847772c 100644
--- a/test/buffer-overrun.js
+++ b/test/buffer-overrun.js
@@ -9,16 +9,16 @@ require(__dirname).test({
     ['error', 'Max buffer length exceeded: tagName\nLine: 0\nColumn: 30\nChar: '],
     ['error', 'Max buffer length exceeded: tagName\nLine: 0\nColumn: 45\nChar: '],
     ['opentagstart', {
-      'name': 'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ',
+      'name': 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
       'attributes': {}
     }],
     ['opentag', {
-      'name': 'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ',
+      'name': 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
       'attributes': {},
       'isSelfClosing': false
     }],
     ['text', 'yo'],
-    ['closetag', 'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ']
+    ['closetag', 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ']
   ]
 }).write('<abcdefghijklmn')
   .write('opqrstuvwxyzABC')
diff --git a/test/case.js b/test/case.js
deleted file mode 100644
index 5b7d2f93..00000000
--- a/test/case.js
+++ /dev/null
@@ -1,62 +0,0 @@
-// default to uppercase
-require(__dirname).test({
-  xml: '<span class="test" hello="world"></span>',
-  expect: [
-    [ 'opentagstart', {
-      name: 'SPAN',
-      attributes: {}
-    } ],
-    [ 'attribute', { name: 'CLASS', value: 'test' } ],
-    [ 'attribute', { name: 'HELLO', value: 'world' } ],
-    [ 'opentag', {
-      name: 'SPAN',
-      attributes: { CLASS: 'test', HELLO: 'world' },
-      isSelfClosing: false
-    } ],
-    [ 'closetag', 'SPAN' ]
-  ],
-  strict: false,
-  opt: {}
-})
-
-// lowercase option : lowercase tag/attribute names
-require(__dirname).test({
-  xml: '<span class="test" hello="world"></span>',
-  expect: [
-    [ 'opentagstart', {
-      name: 'span',
-      attributes: {}
-    } ],
-    [ 'attribute', { name: 'class', value: 'test' } ],
-    [ 'attribute', { name: 'hello', value: 'world' } ],
-    [ 'opentag', {
-      name: 'span',
-      attributes: { class: 'test', hello: 'world' },
-      isSelfClosing: false
-    } ],
-    [ 'closetag', 'span' ]
-  ],
-  strict: false,
-  opt: {lowercase: true}
-})
-
-// backward compatibility with old lowercasetags opt
-require(__dirname).test({
-  xml: '<span class="test" hello="world"></span>',
-  expect: [
-    [ 'opentagstart', {
-      name: 'span',
-      attributes: {}
-    } ],
-    [ 'attribute', { name: 'class', value: 'test' } ],
-    [ 'attribute', { name: 'hello', value: 'world' } ],
-    [ 'opentag', {
-      name: 'span',
-      attributes: { class: 'test', hello: 'world' },
-      isSelfClosing: false
-    } ],
-    [ 'closetag', 'span' ]
-  ],
-  strict: false,
-  opt: {lowercasetags: true}
-})
diff --git a/test/cdata-chunked.js b/test/cdata-chunked.js
index 6ed94a0a..1fba7a68 100644
--- a/test/cdata-chunked.js
+++ b/test/cdata-chunked.js
@@ -1,10 +1,10 @@
 require(__dirname).test({
   expect: [
-    ['opentagstart', {'name': 'R', 'attributes': {}}],
-    ['opentag', {'name': 'R', 'attributes': {}, 'isSelfClosing': false}],
+    ['opentagstart', {'name': 'r', 'attributes': {}}],
+    ['opentag', {'name': 'r', 'attributes': {}, 'isSelfClosing': false}],
     ['opencdata', undefined],
     ['cdata', ' this is character data  '],
     ['closecdata', undefined],
-    ['closetag', 'R']
+    ['closetag', 'r']
   ]
 }).write('<r><![CDATA[ this is ').write('character data  ').write(']]></r>').close()
diff --git a/test/cdata-end-split.js b/test/cdata-end-split.js
index 09dd6126..65e5a9cf 100644
--- a/test/cdata-end-split.js
+++ b/test/cdata-end-split.js
@@ -1,11 +1,11 @@
 require(__dirname).test({
   expect: [
-    ['opentagstart', {'name': 'R', 'attributes': {}}],
-    ['opentag', {'name': 'R', 'attributes': {}, 'isSelfClosing': false}],
+    ['opentagstart', {'name': 'r', 'attributes': {}}],
+    ['opentag', {'name': 'r', 'attributes': {}, 'isSelfClosing': false}],
     ['opencdata', undefined],
     ['cdata', ' this is '],
     ['closecdata', undefined],
-    ['closetag', 'R']
+    ['closetag', 'r']
   ]
 })
   .write('<r><![CDATA[ this is ]')
diff --git a/test/cdata-fake-end.js b/test/cdata-fake-end.js
index 668ad699..e9713b5e 100644
--- a/test/cdata-fake-end.js
+++ b/test/cdata-fake-end.js
@@ -1,11 +1,11 @@
 var p = require(__dirname).test({
   expect: [
-    ['opentagstart', {'name': 'R', 'attributes': {}}],
-    ['opentag', {'name': 'R', 'attributes': {}, 'isSelfClosing': false}],
+    ['opentagstart', {'name': 'r', 'attributes': {}}],
+    ['opentag', {'name': 'r', 'attributes': {}, 'isSelfClosing': false}],
     ['opencdata', undefined],
     ['cdata', '[[[[[[[[]]]]]]]]'],
     ['closecdata', undefined],
-    ['closetag', 'R']
+    ['closetag', 'r']
   ]
 })
 var x = '<r><![CDATA[[[[[[[[[]]]]]]]]]]></r>'
@@ -16,12 +16,12 @@ p.close()
 
 var p2 = require(__dirname).test({
   expect: [
-    ['opentagstart', {'name': 'R', 'attributes': {}}],
-    ['opentag', {'name': 'R', 'attributes': {}, 'isSelfClosing': false}],
+    ['opentagstart', {'name': 'r', 'attributes': {}}],
+    ['opentag', {'name': 'r', 'attributes': {}, 'isSelfClosing': false}],
     ['opencdata', undefined],
     ['cdata', '[[[[[[[[]]]]]]]]'],
     ['closecdata', undefined],
-    ['closetag', 'R']
+    ['closetag', 'r']
   ]
 })
 x = '<r><![CDATA[[[[[[[[[]]]]]]]]]]></r>'
diff --git a/test/cdata-multiple.js b/test/cdata-multiple.js
index 10dce54e..9ef2452b 100644
--- a/test/cdata-multiple.js
+++ b/test/cdata-multiple.js
@@ -1,14 +1,14 @@
 require(__dirname).test({
   expect: [
-    ['opentagstart', {'name': 'R', 'attributes': {}}],
-    ['opentag', {'name': 'R', 'attributes': {}, 'isSelfClosing': false}],
+    ['opentagstart', {'name': 'r', 'attributes': {}}],
+    ['opentag', {'name': 'r', 'attributes': {}, 'isSelfClosing': false}],
     ['opencdata', undefined],
     ['cdata', ' this is '],
     ['closecdata', undefined],
     ['opencdata', undefined],
     ['cdata', 'character data  '],
     ['closecdata', undefined],
-    ['closetag', 'R']
+    ['closetag', 'r']
   ]
 }).write('<r><![CDATA[ this is ]]>').write('<![CDA').write('T').write('A[')
   .write('character data  ').write(']]></r>').close()
diff --git a/test/cdata.js b/test/cdata.js
index 9fb8744c..0b34b0e2 100644
--- a/test/cdata.js
+++ b/test/cdata.js
@@ -1,11 +1,11 @@
 require(__dirname).test({
   xml: '<r><![CDATA[ this is character data  ]]></r>',
   expect: [
-    ['opentagstart', {'name': 'R', 'attributes': {}}],
-    ['opentag', {'name': 'R', 'attributes': {}, 'isSelfClosing': false}],
+    ['opentagstart', {'name': 'r', 'attributes': {}}],
+    ['opentag', {'name': 'r', 'attributes': {}, 'isSelfClosing': false}],
     ['opencdata', undefined],
     ['cdata', ' this is character data  '],
     ['closecdata', undefined],
-    ['closetag', 'R']
+    ['closetag', 'r']
   ]
 })
diff --git a/test/duplicate-attribute.js b/test/duplicate-attribute.js
index 00303629..ca0e191f 100644
--- a/test/duplicate-attribute.js
+++ b/test/duplicate-attribute.js
@@ -2,17 +2,16 @@ require(__dirname).test({
   xml: '<span id="hello" id="there"></span>',
   expect: [
     [ 'opentagstart', {
-      name: 'SPAN',
+      name: 'span',
       attributes: {}
     } ],
-    [ 'attribute', { name: 'ID', value: 'hello' } ],
+    [ 'attribute', { name: 'id', value: 'hello' } ],
     [ 'opentag', {
-      name: 'SPAN',
-      attributes: { ID: 'hello' },
+      name: 'span',
+      attributes: { id: 'hello' },
       isSelfClosing: false
     } ],
-    [ 'closetag', 'SPAN' ]
+    [ 'closetag', 'span' ]
   ],
-  strict: false,
   opt: {}
 })
diff --git a/test/emoji.js b/test/emoji.js
index bddf1772..ea86bf84 100644
--- a/test/emoji.js
+++ b/test/emoji.js
@@ -2,11 +2,10 @@
 require(__dirname).test({
   xml: '<a>&#x1f525;</a>',
   expect: [
-    [ 'opentagstart', { name: 'A', attributes: {} } ],
-    [ 'opentag', { name: 'A', attributes: {}, isSelfClosing: false } ],
+    [ 'opentagstart', { name: 'a', attributes: {} } ],
+    [ 'opentag', { name: 'a', attributes: {}, isSelfClosing: false } ],
     [ 'text', '\ud83d\udd25' ],
-    [ 'closetag', 'A' ]
+    [ 'closetag', 'a' ]
   ],
-  strict: false,
   opt: {}
 })
diff --git a/test/entities.js b/test/entities.js
index 516ee171..750bfd9a 100644
--- a/test/entities.js
+++ b/test/entities.js
@@ -1,11 +1,11 @@
 require(__dirname).test({
   xml: '<r>&rfloor; ' +
     '&spades; &copy; &rarr; &amp; ' +
-    '&lt; < <  <   < &gt; &real; &weierp; &euro;</r>',
+    '&lt; &gt; > &real; &weierp; &euro;</r>',
   expect: [
-    ['opentagstart', {'name': 'R', attributes: {}}],
-    ['opentag', {'name': 'R', attributes: {}, isSelfClosing: false}],
-    ['text', '⌋ ♠ © → & < < <  <   < > ℜ ℘ €'],
-    ['closetag', 'R']
+    ['opentagstart', {'name': 'r', attributes: {}}],
+    ['opentag', {'name': 'r', attributes: {}, isSelfClosing: false}],
+    ['text', '⌋ ♠ © → & < > > ℜ ℘ €'],
+    ['closetag', 'r']
   ]
 })
diff --git a/test/entity-mega.js b/test/entity-mega.js
index a6c786fc..5798f1ac 100644
--- a/test/entity-mega.js
+++ b/test/entity-mega.js
@@ -9,9 +9,9 @@ xml += '</r>'
 require(__dirname).test({
   xml: xml,
   expect: [
-    ['opentagstart', {'name': 'R', attributes: {}}],
-    ['opentag', {'name': 'R', attributes: {}, isSelfClosing: false}],
+    ['opentagstart', {'name': 'r', attributes: {}}],
+    ['opentag', {'name': 'r', attributes: {}, isSelfClosing: false}],
     ['text', text],
-    ['closetag', 'R']
+    ['closetag', 'r']
   ]
 })
diff --git a/test/entity-nan.js b/test/entity-nan.js
index a56be4b0..4565b43f 100644
--- a/test/entity-nan.js
+++ b/test/entity-nan.js
@@ -1,9 +1,13 @@
 require(__dirname).test({
   xml: '<r>&#NaN;</r>',
   expect: [
-    ['opentagstart', {'name': 'R', attributes: {}}],
-    ['opentag', {'name': 'R', attributes: {}, isSelfClosing: false}],
+    ['opentagstart', {'name': 'r', attributes: {}}],
+    ['opentag', {'name': 'r', attributes: {}, isSelfClosing: false}],
+    ['error', 'Invalid character entity\n\
+Line: 0\n\
+Column: 9\n\
+Char: ;'],
     ['text', '&#NaN;'],
-    ['closetag', 'R']
+    ['closetag', 'r']
   ]
 })
diff --git a/test/index.js b/test/index.js
index c00af475..3e6681cc 100644
--- a/test/index.js
+++ b/test/index.js
@@ -9,7 +9,7 @@ exports.saxes = saxes
 // otherwise, it's assumed that the test will write and close.
 exports.test = function test (options) {
   var xml = options.xml
-  var parser = saxes.parser(options.strict, options.opt)
+  var parser = saxes.parser(options.opt)
   var expect = options.expect
   var e = 0
   saxes.EVENTS.forEach(function (ev) {
diff --git a/test/issue-23.js b/test/issue-23.js
index 9ebee7e6..fcd0436a 100644
--- a/test/issue-23.js
+++ b/test/issue-23.js
@@ -10,37 +10,36 @@ require(__dirname).test({
     '</result>' +
     '</compileClassesResponse>',
   expect: [
-    [ 'opentagstart', { name: 'COMPILECLASSESRESPONSE', attributes: {} } ],
-    [ 'opentag', { name: 'COMPILECLASSESRESPONSE', attributes: {}, isSelfClosing: false } ],
-    [ 'opentagstart', { name: 'RESULT', attributes: {} } ],
-    [ 'opentag', { name: 'RESULT', attributes: {}, isSelfClosing: false } ],
-    [ 'opentagstart', { name: 'BODYCRC', attributes: {} } ],
-    [ 'opentag', { name: 'BODYCRC', attributes: {}, isSelfClosing: false } ],
+    [ 'opentagstart', { name: 'compileClassesResponse', attributes: {} } ],
+    [ 'opentag', { name: 'compileClassesResponse', attributes: {}, isSelfClosing: false } ],
+    [ 'opentagstart', { name: 'result', attributes: {} } ],
+    [ 'opentag', { name: 'result', attributes: {}, isSelfClosing: false } ],
+    [ 'opentagstart', { name: 'bodyCrc', attributes: {} } ],
+    [ 'opentag', { name: 'bodyCrc', attributes: {}, isSelfClosing: false } ],
     [ 'text', '653724009' ],
-    [ 'closetag', 'BODYCRC' ],
-    [ 'opentagstart', { name: 'COLUMN', attributes: {} } ],
-    [ 'opentag', { name: 'COLUMN', attributes: {}, isSelfClosing: false } ],
+    [ 'closetag', 'bodyCrc' ],
+    [ 'opentagstart', { name: 'column', attributes: {} } ],
+    [ 'opentag', { name: 'column', attributes: {}, isSelfClosing: false } ],
     [ 'text', '-1' ],
-    [ 'closetag', 'COLUMN' ],
-    [ 'opentagstart', { name: 'ID', attributes: {} } ],
-    [ 'opentag', { name: 'ID', attributes: {}, isSelfClosing: false } ],
+    [ 'closetag', 'column' ],
+    [ 'opentagstart', { name: 'id', attributes: {} } ],
+    [ 'opentag', { name: 'id', attributes: {}, isSelfClosing: false } ],
     [ 'text', '01pG0000002KoSUIA0' ],
-    [ 'closetag', 'ID' ],
-    [ 'opentagstart', { name: 'LINE', attributes: {} } ],
-    [ 'opentag', { name: 'LINE', attributes: {}, isSelfClosing: false } ],
+    [ 'closetag', 'id' ],
+    [ 'opentagstart', { name: 'line', attributes: {} } ],
+    [ 'opentag', { name: 'line', attributes: {}, isSelfClosing: false } ],
     [ 'text', '-1' ],
-    [ 'closetag', 'LINE' ],
-    [ 'opentagstart', { name: 'NAME', attributes: {} } ],
-    [ 'opentag', { name: 'NAME', attributes: {}, isSelfClosing: false } ],
+    [ 'closetag', 'line' ],
+    [ 'opentagstart', { name: 'name', attributes: {} } ],
+    [ 'opentag', { name: 'name', attributes: {}, isSelfClosing: false } ],
     [ 'text', 'CalendarController' ],
-    [ 'closetag', 'NAME' ],
-    [ 'opentagstart', { name: 'SUCCESS', attributes: {} } ],
-    [ 'opentag', { name: 'SUCCESS', attributes: {}, isSelfClosing: false } ],
+    [ 'closetag', 'name' ],
+    [ 'opentagstart', { name: 'success', attributes: {} } ],
+    [ 'opentag', { name: 'success', attributes: {}, isSelfClosing: false } ],
     [ 'text', 'true' ],
-    [ 'closetag', 'SUCCESS' ],
-    [ 'closetag', 'RESULT' ],
-    [ 'closetag', 'COMPILECLASSESRESPONSE' ]
+    [ 'closetag', 'success' ],
+    [ 'closetag', 'result' ],
+    [ 'closetag', 'compileClassesResponse' ]
   ],
-  strict: false,
   opt: {}
 })
diff --git a/test/issue-30.js b/test/issue-30.js
index 0c79cb28..6549c4f4 100644
--- a/test/issue-30.js
+++ b/test/issue-30.js
@@ -18,6 +18,5 @@ require(__dirname).test({
     [ 'text', '\n' ],
     [ 'closetag', 'xml' ]
   ],
-  strict: true,
   opt: {}
 })
diff --git a/test/issue-35.js b/test/issue-35.js
index ed0c6c00..2db4d170 100644
--- a/test/issue-35.js
+++ b/test/issue-35.js
@@ -7,6 +7,5 @@ require(__dirname).test({
     [ 'text', '\r\r\n' ],
     [ 'closetag', 'xml' ]
   ],
-  strict: true,
   opt: {}
 })
diff --git a/test/issue-47.js b/test/issue-47.js
index 2b85e13b..d88a1e9d 100644
--- a/test/issue-47.js
+++ b/test/issue-47.js
@@ -1,11 +1,11 @@
 // https://github.com/isaacs/sax-js/issues/47
 require(__dirname).test({
-  xml: '<a href="query.svc?x=1&y=2&z=3"/>',
+  xml: '<a href="query.svc?x=1&amp;y=2&amp;z=3"/>',
   expect: [
-    [ 'opentagstart', { name: 'A', attributes: {} } ],
-    [ 'attribute', { name: 'HREF', value: 'query.svc?x=1&y=2&z=3' } ],
-    [ 'opentag', { name: 'A', attributes: { HREF: 'query.svc?x=1&y=2&z=3' }, isSelfClosing: true } ],
-    [ 'closetag', 'A' ]
+    [ 'opentagstart', { name: 'a', attributes: {} } ],
+    [ 'attribute', { name: 'href', value: 'query.svc?x=1&y=2&z=3' } ],
+    [ 'opentag', { name: 'a', attributes: { href: 'query.svc?x=1&y=2&z=3' }, isSelfClosing: true } ],
+    [ 'closetag', 'a' ]
   ],
   opt: {}
 })
diff --git a/test/issue-49.js b/test/issue-49.js
index 7918666b..7ba4f117 100644
--- a/test/issue-49.js
+++ b/test/issue-49.js
@@ -10,7 +10,6 @@ require(__dirname).test({
     [ 'closetag', 'script' ],
     [ 'closetag', 'xml' ]
   ],
-  strict: false,
   opt: { lowercasetags: true, noscript: true }
 })
 
@@ -27,6 +26,5 @@ require(__dirname).test({
     [ 'closetag', 'script' ],
     [ 'closetag', 'xml' ]
   ],
-  strict: false,
   opt: { lowercasetags: true, noscript: true }
 })
diff --git a/test/issue-84.js b/test/issue-84.js
index 9a2195e3..f68918c8 100644
--- a/test/issue-84.js
+++ b/test/issue-84.js
@@ -8,6 +8,5 @@ require(__dirname).test({
     [ 'text', 'body' ],
     [ 'closetag', 'xml' ]
   ],
-  strict: false,
   opt: { lowercasetags: true, noscript: true }
 })
diff --git a/test/issue-86.js b/test/issue-86.js
index 00e27d5b..28c6fc7a 100644
--- a/test/issue-86.js
+++ b/test/issue-86.js
@@ -1,38 +1,3 @@
-require(__dirname).test({
-  xml: '<root>abc</root>de<f',
-  expect: [
-    [
-      'opentagstart',
-      {
-        name: 'ROOT',
-        attributes: {}
-      }
-    ],
-    [
-      'opentag',
-      {
-        name: 'ROOT',
-        attributes: {},
-        isSelfClosing: false
-      }
-    ],
-    [
-      'text',
-      'abc'
-    ],
-    [
-      'closetag',
-      'ROOT'
-    ],
-    [
-      'text',
-      'de<f'
-    ]
-  ],
-  strict: false,
-  opt: {}
-})
-
 require(__dirname).test({
   xml: '<root>abc</root>de<f',
   expect: [
@@ -80,6 +45,5 @@ require(__dirname).test({
       'Unexpected end\nLine: 0\nColumn: 20\nChar: '
     ]
   ],
-  strict: true,
   opt: {}
 })
diff --git a/test/opentagstart.js b/test/opentagstart.js
index 6aeb0193..f8397245 100644
--- a/test/opentagstart.js
+++ b/test/opentagstart.js
@@ -44,7 +44,6 @@ require(__dirname).test({
       'root'
     ]
   ],
-  strict: true,
   opt: {
     xmlns: true
   }
@@ -82,5 +81,4 @@ require(__dirname).test({
       'root'
     ]
   ],
-  strict: true
 })
diff --git a/test/script-close-better.js b/test/script-close-better.js
deleted file mode 100644
index a7966937..00000000
--- a/test/script-close-better.js
+++ /dev/null
@@ -1,15 +0,0 @@
-require(__dirname).test({
-  xml: "<html><head><script>'<div>foo</div></'</script></head></html>",
-  expect: [
-    ['opentagstart', {'name': 'HTML', 'attributes': {}}],
-    ['opentag', {'name': 'HTML', 'attributes': {}, isSelfClosing: false}],
-    ['opentagstart', {'name': 'HEAD', 'attributes': {}}],
-    ['opentag', {'name': 'HEAD', 'attributes': {}, isSelfClosing: false}],
-    ['opentagstart', {'name': 'SCRIPT', 'attributes': {}}],
-    ['opentag', {'name': 'SCRIPT', 'attributes': {}, isSelfClosing: false}],
-    ['script', "'<div>foo</div></'"],
-    ['closetag', 'SCRIPT'],
-    ['closetag', 'HEAD'],
-    ['closetag', 'HTML']
-  ]
-})
diff --git a/test/script.js b/test/script.js
deleted file mode 100644
index c30d6dc8..00000000
--- a/test/script.js
+++ /dev/null
@@ -1,66 +0,0 @@
-require(__dirname).test({
-  xml: "<html><head><script>if (1 < 0) { console.log('elo there'); }</script></head></html>",
-  expect: [
-    [
-      'opentagstart',
-      {
-        'name': 'HTML',
-        'attributes': {}
-      }
-    ],
-    [
-      'opentag',
-      {
-        'name': 'HTML',
-        'attributes': {},
-        'isSelfClosing': false
-      }
-    ],
-    [
-      'opentagstart',
-      {
-        'name': 'HEAD',
-        'attributes': {}
-      }
-    ],
-    [
-      'opentag',
-      {
-        'name': 'HEAD',
-        'attributes': {},
-        'isSelfClosing': false
-      }
-    ],
-    [
-      'opentagstart',
-      {
-        'name': 'SCRIPT',
-        'attributes': {}
-      }
-    ],
-    [
-      'opentag',
-      {
-        'name': 'SCRIPT',
-        'attributes': {},
-        'isSelfClosing': false
-      }
-    ],
-    [
-      'script',
-      "if (1 < 0) { console.log('elo there'); }"
-    ],
-    [
-      'closetag',
-      'SCRIPT'
-    ],
-    [
-      'closetag',
-      'HEAD'
-    ],
-    [
-      'closetag',
-      'HTML'
-    ]
-  ]
-})
diff --git a/test/self-closing-child-strict.js b/test/self-closing-child-strict.js
deleted file mode 100644
index 359670af..00000000
--- a/test/self-closing-child-strict.js
+++ /dev/null
@@ -1,57 +0,0 @@
-require(__dirname).test({
-  xml: '<root>' +
-    '<child>' +
-    '<haha />' +
-    '</child>' +
-    '<monkey>' +
-    '=(|)' +
-    '</monkey>' +
-    '</root>',
-  expect: [
-    ['opentagstart', {
-      'name': 'root',
-      'attributes': {}
-    }],
-    ['opentag', {
-      'name': 'root',
-      'attributes': {},
-      'isSelfClosing': false
-    }],
-    ['opentagstart', {
-      'name': 'child',
-      'attributes': {}
-    }],
-    ['opentag', {
-      'name': 'child',
-      'attributes': {},
-      'isSelfClosing': false
-    }],
-    ['opentagstart', {
-      'name': 'haha',
-      'attributes': {}
-    }],
-    ['opentag', {
-      'name': 'haha',
-      'attributes': {},
-      'isSelfClosing': true
-    }],
-    ['closetag', 'haha'],
-    ['closetag', 'child'],
-    ['opentagstart', {
-      'name': 'monkey',
-      'attributes': {}
-    }],
-    ['opentag', {
-      'name': 'monkey',
-      'attributes': {},
-      'isSelfClosing': false
-    }],
-    ['text', '=(|)'],
-    ['closetag', 'monkey'],
-    ['closetag', 'root'],
-    ['end'],
-    ['ready']
-  ],
-  strict: true,
-  opt: {}
-})
diff --git a/test/self-closing-child.js b/test/self-closing-child.js
index e24a17ba..e6e34cfd 100644
--- a/test/self-closing-child.js
+++ b/test/self-closing-child.js
@@ -9,49 +9,48 @@ require(__dirname).test({
     '</root>',
   expect: [
     ['opentagstart', {
-      'name': 'ROOT',
+      'name': 'root',
       'attributes': {}
     }],
     ['opentag', {
-      'name': 'ROOT',
+      'name': 'root',
       'attributes': {},
       'isSelfClosing': false
     }],
     ['opentagstart', {
-      'name': 'CHILD',
+      'name': 'child',
       'attributes': {}
     }],
     ['opentag', {
-      'name': 'CHILD',
+      'name': 'child',
       'attributes': {},
       'isSelfClosing': false
     }],
     ['opentagstart', {
-      'name': 'HAHA',
+      'name': 'haha',
       'attributes': {}
     }],
     ['opentag', {
-      'name': 'HAHA',
+      'name': 'haha',
       'attributes': {},
       'isSelfClosing': true
     }],
-    ['closetag', 'HAHA'],
-    ['closetag', 'CHILD'],
+    ['closetag', 'haha'],
+    ['closetag', 'child'],
     ['opentagstart', {
-      'name': 'MONKEY',
+      'name': 'monkey',
       'attributes': {}
     }],
     ['opentag', {
-      'name': 'MONKEY',
+      'name': 'monkey',
       'attributes': {},
       'isSelfClosing': false
     }],
     ['text', '=(|)'],
-    ['closetag', 'MONKEY'],
-    ['closetag', 'ROOT'],
+    ['closetag', 'monkey'],
+    ['closetag', 'root'],
     ['end'],
     ['ready']
   ],
-  strict: false,
   opt: {}
 })
diff --git a/test/self-closing-tag.js b/test/self-closing-tag.js
index 4e1bd7df..72839971 100644
--- a/test/self-closing-tag.js
+++ b/test/self-closing-tag.js
@@ -7,21 +7,21 @@ require(__dirname).test({
     '</monkey>' +
     '</root>  ',
   expect: [
-    ['opentagstart', {name: 'ROOT', attributes: {}}],
-    ['opentag', {name: 'ROOT', attributes: {}, isSelfClosing: false}],
-    ['opentagstart', {name: 'HAHA', attributes: {}}],
-    ['opentag', {name: 'HAHA', attributes: {}, isSelfClosing: true}],
-    ['closetag', 'HAHA'],
-    ['opentagstart', {name: 'HAHA', attributes: {}}],
-    ['opentag', {name: 'HAHA', attributes: {}, isSelfClosing: true}],
-    ['closetag', 'HAHA'],
-    // ["opentag", {name:"HAHA", attributes:{}}],
-    // ["closetag", "HAHA"],
-    ['opentagstart', {name: 'MONKEY', attributes: {}}],
-    ['opentag', {name: 'MONKEY', attributes: {}, isSelfClosing: false}],
+    ['opentagstart', {name: 'root', attributes: {}}],
+    ['opentag', {name: 'root', attributes: {}, isSelfClosing: false}],
+    ['opentagstart', {name: 'haha', attributes: {}}],
+    ['opentag', {name: 'haha', attributes: {}, isSelfClosing: true}],
+    ['closetag', 'haha'],
+    ['opentagstart', {name: 'haha', attributes: {}}],
+    ['opentag', {name: 'haha', attributes: {}, isSelfClosing: true}],
+    ['closetag', 'haha'],
+    // ["opentag", {name:"haha", attributes:{}}],
+    // ["closetag", "haha"],
+    ['opentagstart', {name: 'monkey', attributes: {}}],
+    ['opentag', {name: 'monkey', attributes: {}, isSelfClosing: false}],
     ['text', '=(|)'],
-    ['closetag', 'MONKEY'],
-    ['closetag', 'ROOT']
+    ['closetag', 'monkey'],
+    ['closetag', 'root']
   ],
   opt: { trim: true }
 })
diff --git a/test/stand-alone-comment.js b/test/stand-alone-comment.js
index a13a8b03..207b4f63 100644
--- a/test/stand-alone-comment.js
+++ b/test/stand-alone-comment.js
@@ -7,6 +7,5 @@ require(__dirname).test({
       ' stand alone comment '
     ]
   ],
-  strict: true,
   opt: {}
 })
diff --git a/test/stray-ending.js b/test/stray-ending.js
deleted file mode 100644
index 2577c481..00000000
--- a/test/stray-ending.js
+++ /dev/null
@@ -1,51 +0,0 @@
-// stray ending tags should just be ignored in non-strict mode.
-// https://github.com/isaacs/sax-js/issues/32
-require(__dirname).test({
-  xml: '<a><b></c></b></a>',
-  expect: [
-    [
-      'opentagstart',
-      {
-        name: 'A',
-        attributes: {}
-      }
-    ],
-    [
-      'opentag',
-      {
-        name: 'A',
-        attributes: {},
-        isSelfClosing: false
-      }
-    ],
-    [
-      'opentagstart',
-      {
-        name: 'B',
-        attributes: {}
-      }
-    ],
-    [
-      'opentag',
-      {
-        name: 'B',
-        attributes: {},
-        isSelfClosing: false
-      }
-    ],
-    [
-      'text',
-      '</c>'
-    ],
-    [
-      'closetag',
-      'B'
-    ],
-    [
-      'closetag',
-      'A'
-    ]
-  ],
-  strict: false,
-  opt: {}
-})
diff --git a/test/trailing-attribute-no-value.js b/test/trailing-attribute-no-value.js
index e6403225..1a8ce7aa 100644
--- a/test/trailing-attribute-no-value.js
+++ b/test/trailing-attribute-no-value.js
@@ -1,9 +1,14 @@
 require(__dirname).test({
-  xml: '<root attrib>',
+  xml: '<root attrib></root>',
   expect: [
-    ['opentagstart', {name: 'ROOT', attributes: {}}],
-    ['attribute', {name: 'ATTRIB', value: 'attrib'}],
-    ['opentag', {name: 'ROOT', attributes: {'ATTRIB': 'attrib'}, isSelfClosing: false}]
+    ['opentagstart', {name: 'root', attributes: {}}],
+    ['error', 'Attribute without value\n\
+Line: 0\n\
+Column: 13\n\
+Char: >'],
+    ['attribute', {name: 'attrib', value: 'attrib'}],
+    ['opentag', {name: 'root', attributes: {'attrib': 'attrib'}, isSelfClosing: false}],
+    ['closetag', 'root'],
   ],
   opt: { trim: true }
 })
diff --git a/test/trailing-non-whitespace.js b/test/trailing-non-whitespace.js
index 8212d6ce..0e4876d6 100644
--- a/test/trailing-non-whitespace.js
+++ b/test/trailing-non-whitespace.js
@@ -2,20 +2,34 @@ require(__dirname).test({
   xml: '<span>Welcome,</span> to monkey land',
   expect: [
     ['opentagstart', {
-      'name': 'SPAN',
+      'name': 'span',
       'attributes': {}
     }],
     ['opentag', {
-      'name': 'SPAN',
+      'name': 'span',
       'attributes': {},
       isSelfClosing: false
     }],
     ['text', 'Welcome,'],
-    ['closetag', 'SPAN'],
-    ['text', ' to monkey land'],
+    ['closetag', 'span'],
+    ['text', ' '],
+    ['error', 'Text data outside of root node.\n\
+Line: 0\n\
+Column: 23\n\
+Char: t'],
+    ['text', 't'],
+    ['error', 'Text data outside of root node.\n\
+Line: 0\n\
+Column: 24\n\
+Char: o'],
+    ['text', 'o '],
+    ['error', 'Text data outside of root node.\n\
+Line: 0\n\
+Column: 26\n\
+Char: m'],
+    ['text', 'm'],
     ['end'],
     ['ready']
   ],
-  strict: false,
   opt: {}
 })
diff --git a/test/unclosed-root.js b/test/unclosed-root.js
index dbd1178a..58951f9a 100644
--- a/test/unclosed-root.js
+++ b/test/unclosed-root.js
@@ -21,6 +21,5 @@ require(__dirname).test({
       'Unclosed root tag\nLine: 0\nColumn: 6\nChar: '
     ]
   ],
-  strict: true,
   opt: {}
 })
diff --git a/test/unquoted.js b/test/unquoted.js
deleted file mode 100644
index 4bbd511c..00000000
--- a/test/unquoted.js
+++ /dev/null
@@ -1,45 +0,0 @@
-// unquoted attributes should be ok in non-strict mode
-// https://github.com/isaacs/sax-js/issues/31
-require(__dirname).test({
-  xml: '<span class=test hello=world></span>',
-  expect: [
-    [
-      'opentagstart',
-      {
-        name: 'SPAN',
-        attributes: {}
-      }
-    ],
-    [
-      'attribute',
-      {
-        name: 'CLASS',
-        value: 'test'
-      }
-    ],
-    [
-      'attribute',
-      {
-        name: 'HELLO',
-        value: 'world'
-      }
-    ],
-    [
-      'opentag',
-      {
-        name: 'SPAN',
-        attributes: {
-          CLASS: 'test',
-          HELLO: 'world'
-        },
-        isSelfClosing: false
-      }
-    ],
-    [
-      'closetag',
-      'SPAN'
-    ]
-  ],
-  strict: false,
-  opt: {}
-})
diff --git a/test/utf8-split.js b/test/utf8-split.js
index a4b1df1e..f917800f 100644
--- a/test/utf8-split.js
+++ b/test/utf8-split.js
@@ -30,5 +30,5 @@ saxesStream2.write(new Buffer('<e>'))
 saxesStream2.write(new Buffer([0xC0]))
 saxesStream2.write(new Buffer('</e>'))
 saxesStream2.write(Buffer.concat([new Buffer('<f>'), b.slice(0, 1)]))
-saxesStream2.write(new Buffer('</root>'))
+saxesStream2.write(new Buffer('</f></root>'))
 saxesStream2.end()
diff --git a/test/xml-internal-entities.js b/test/xml-internal-entities.js
index 3c49e500..6d444e1c 100644
--- a/test/xml-internal-entities.js
+++ b/test/xml-internal-entities.js
@@ -81,7 +81,6 @@ iExpect.push([
 iExpect.push([ 'closetag', 'a' ])
 
 var parser = require(__dirname).test({
-  strict: true,
   expect: iExpect
 })
 
diff --git a/test/xml_entities.js b/test/xml_entities.js
deleted file mode 100644
index 3d739d0d..00000000
--- a/test/xml_entities.js
+++ /dev/null
@@ -1,12 +0,0 @@
-require(__dirname).test({
-  opt: { strictEntities: true },
-  xml: '<r>&rfloor; ' +
-    '&spades; &copy; &rarr; &amp; ' +
-    '&lt; < <  <   < &gt; &real; &weierp; &euro;</r>',
-  expect: [
-    ['opentagstart', {'name': 'R', attributes: {}}],
-    ['opentag', {'name': 'R', attributes: {}, isSelfClosing: false}],
-    ['text', '&rfloor; &spades; &copy; &rarr; & < < <  <   < > &real; &weierp; &euro;'],
-    ['closetag', 'R']
-  ]
-})
diff --git a/test/xmlns-as-tag-name.js b/test/xmlns-as-tag-name.js
index 18cd44d6..db10ecc6 100644
--- a/test/xmlns-as-tag-name.js
+++ b/test/xmlns-as-tag-name.js
@@ -26,7 +26,6 @@ require(__dirname).test({
       'xmlns'
     ]
   ],
-  strict: true,
   opt: {
     xmlns: true
   }
diff --git a/test/xmlns-issue-41.js b/test/xmlns-issue-41.js
index 435b7e6c..e526c234 100644
--- a/test/xmlns-issue-41.js
+++ b/test/xmlns-issue-41.js
@@ -85,7 +85,6 @@ xmls.forEach(function (x, i) {
   t.test({
     xml: x,
     expect: expected[i],
-    strict: true,
     opt: {
       xmlns: true
     }
diff --git a/test/xmlns-rebinding.js b/test/xmlns-rebinding.js
index 8086b447..78579c0c 100644
--- a/test/xmlns-rebinding.js
+++ b/test/xmlns-rebinding.js
@@ -320,7 +320,6 @@ require(__dirname).test({
       }
     ]
   ],
-  strict: true,
   opt: {
     xmlns: true
   }
diff --git a/test/xmlns-strict.js b/test/xmlns-strict.js
index 87d26c44..79f37079 100644
--- a/test/xmlns-strict.js
+++ b/test/xmlns-strict.js
@@ -327,7 +327,6 @@ require(__dirname).test({
       'root'
     ]
   ],
-  strict: true,
   opt: {
     xmlns: true
   }
diff --git a/test/xmlns-unbound-element.js b/test/xmlns-unbound-element.js
index 60759b1d..422763ad 100644
--- a/test/xmlns-unbound-element.js
+++ b/test/xmlns-unbound-element.js
@@ -1,5 +1,4 @@
 require(__dirname).test({
-  strict: true,
   opt: { xmlns: true },
   expect: [
     [
@@ -34,7 +33,6 @@ require(__dirname).test({
 }).write('<unbound:root/>')
 
 require(__dirname).test({
-  strict: true,
   opt: {
     xmlns: true
   },
diff --git a/test/xmlns-unbound.js b/test/xmlns-unbound.js
index 319d3504..76159fc8 100644
--- a/test/xmlns-unbound.js
+++ b/test/xmlns-unbound.js
@@ -1,5 +1,4 @@
 require(__dirname).test({
-  strict: true,
   opt: { xmlns: true },
   expect: [
     [
diff --git a/test/xmlns-xml-default-ns.js b/test/xmlns-xml-default-ns.js
index 41d55720..321f0894 100644
--- a/test/xmlns-xml-default-ns.js
+++ b/test/xmlns-xml-default-ns.js
@@ -64,7 +64,6 @@ require(__dirname).test({
       }
     ]
   ],
-  strict: true,
   opt: {
     xmlns: true
   }
diff --git a/test/xmlns-xml-default-prefix-attribute.js b/test/xmlns-xml-default-prefix-attribute.js
index 51cfbb6f..6750b191 100644
--- a/test/xmlns-xml-default-prefix-attribute.js
+++ b/test/xmlns-xml-default-prefix-attribute.js
@@ -44,6 +44,5 @@ require(__dirname).test({
       'root'
     ]
   ],
-  strict: true,
   opt: { xmlns: true }
 })
diff --git a/test/xmlns-xml-default-prefix.js b/test/xmlns-xml-default-prefix.js
index fd48cbdd..dfd210a8 100644
--- a/test/xmlns-xml-default-prefix.js
+++ b/test/xmlns-xml-default-prefix.js
@@ -26,6 +26,5 @@ require(__dirname).test({
       'xml:root'
     ]
   ],
-  strict: true,
   opt: { xmlns: true }
 })
diff --git a/test/xmlns-xml-default-redefine.js b/test/xmlns-xml-default-redefine.js
index 2a8f7050..da6c30e3 100644
--- a/test/xmlns-xml-default-redefine.js
+++ b/test/xmlns-xml-default-redefine.js
@@ -50,6 +50,5 @@ require(__dirname).test({
       'xml:root'
     ]
   ],
-  strict: true,
   opt: { xmlns: true }
 })