Improve tests; update to Swift 3.0.1

Author: youming-lin

.swift-version

@@ -1 +1 @@
-3.0
+3.0.1

.travis.yml

@@ -23,4 +23,4 @@ before_install:
   - git submodule update --init --remote --merge --recursive
 
 script:
-  - ./Package-Builder/build-package.sh $TRAVIS_BRANCH $TRAVIS_BUILD_DIR
+  - ./Package-Builder/build-package.sh $TRAVIS_BUILD_DIR

Package-Builder

@@ -6,7 +6,7 @@
 ![Apache 2](https://img.shields.io/badge/license-Apache2-blue.svg?style=flat)
 
 ## Summary
-Pure Swift HTML encode/decode utility tool for Swift 3.0.
+Pure Swift HTML encode/decode utility tool for Swift 3.
 
 Now includes support for HTML5 named character references. You can find the list of all 2231 HTML5 named character references [here](https://www.w3.org/TR/html5/syntax.html#named-character-references).
 
@@ -24,12 +24,14 @@ In addition, `HTMLEntities` can unescape encoded HTML text that contains decimal
 
 ## Version Info
 
-HTMLEntities 2.0 runs on Swift 3.0, on both macOS and Ubuntu Linux.
+HTMLEntities 2.0 runs on Swift 3, on both macOS and Ubuntu Linux.
 
 ## Usage
 
 ### Install via Swift Package Manager (SPM)
 
+Add `HTMLEntities` to your `Package.swift`:
+
 ```swift
 import PackageDescription
 

README.md

@@ -61,13 +61,13 @@ class HTMLEntitiesTests: XCTestCase {
 
             do {
                 _ = try escaped.htmlUnescape(strict: true)
-                XCTAssert(false)
+                XCTFail("Did not throw error")
             }
             catch ParseError.MissingSemicolon {
                 XCTAssert(true)
             }
             catch {
-                XCTAssert(false)
+                XCTFail("Wrong error thrown")
             }
         }
 
@@ -99,13 +99,13 @@ class HTMLEntitiesTests: XCTestCase {
 
             do {
                 _ = try decEscaped.htmlUnescape(strict: true)
-                XCTAssert(false)
+                XCTFail("Did not throw error")
             }
             catch ParseError.DeprecatedNumericReference {
                 XCTAssert(true)
             }
             catch {
-                XCTAssert(false)
+                XCTFail("Wrong error thrown")
             }
 
             do {
@@ -116,7 +116,7 @@ class HTMLEntitiesTests: XCTestCase {
                 XCTAssert(true)
             }
             catch {
-                XCTAssert(false)
+                XCTFail("Wrong error thrown")
             }
         }
 
@@ -135,23 +135,24 @@ class HTMLEntitiesTests: XCTestCase {
 
             do {
                 _ = try decEscaped.htmlUnescape(strict: true)
-                XCTAssert(false)
+                XCTFail("Did not throw error")
             }
             catch ParseError.OutsideValidUnicodeRange {
                 XCTAssert(true)
             }
             catch {
-                XCTAssert(false)
+                XCTFail("Wrong error thrown")
             }
 
             do {
                 _ = try hexEscaped.htmlUnescape(strict: true)
+                XCTFail("Did not throw error")
             }
             catch ParseError.OutsideValidUnicodeRange {
                 XCTAssert(true)
             }
             catch {
-                XCTAssert(false)
+                XCTFail("Wrong error thrown")
             }
         }
 
@@ -178,24 +179,24 @@ class HTMLEntitiesTests: XCTestCase {
 
             do {
                 _ = try decEscaped.htmlUnescape(strict: true)
-                XCTAssert(false)
+                XCTFail("Did not throw error")
             }
             catch ParseError.DisallowedNumericReference {
                 XCTAssert(true)
             }
             catch {
-                XCTAssert(false)
+                XCTFail("Wrong error thrown")
             }
 
             do {
                 _ = try hexEscaped.htmlUnescape(strict: true)
-                XCTAssert(false)
+                XCTFail("Did not throw error")
             }
             catch ParseError.DisallowedNumericReference {
                 XCTAssert(true)
             }
             catch {
-                XCTAssert(false)
+                XCTFail("Wrong error thrown")
             }
         }
     }
@@ -238,41 +239,41 @@ class HTMLEntitiesTests: XCTestCase {
 
         do {
             _ = try "&#4370ᅡ&#4523".htmlUnescape(strict: true)
-            XCTAssert(false)
+            XCTFail("Did not throw error")
         }
         catch ParseError.MissingSemicolon {
             XCTAssert(true)
         }
         catch {
-            XCTAssert(false)
+            XCTFail("Wrong error thrown")
         }
 
         let badEntity = "&some &text; here <script> some more; text here;"
         XCTAssertEqual(badEntity.htmlUnescape(), "&some &text; here <script> some more; text here;")
 
         do {
             _ = try badEntity.htmlUnescape(strict: true)
-            XCTAssert(false)
+            XCTFail("Did not throw error")
         }
         catch ParseError.InvalidNamedReference {
             XCTAssert(true)
         }
         catch {
-            XCTAssert(false)
+            XCTFail("Wrong error thrown")
         }
 
         let legacyEmbedded = "I'm &notit; I tell you"
         XCTAssertEqual(legacyEmbedded.htmlUnescape(), "I'm ¬it; I tell you")
 
         do {
             _ = try legacyEmbedded.htmlUnescape(strict: true)
-            XCTAssert(false)
+            XCTFail("Did not throw error")
         }
         catch ParseError.MissingSemicolon {
             XCTAssert(true)
         }
         catch {
-            XCTAssert(false)
+            XCTFail("Wrong error thrown")
         }
 
         XCTAssertEqual(try "&&#x223E;&#x333;".htmlUnescape(strict: true), "&∾̳")
@@ -281,26 +282,26 @@ class HTMLEntitiesTests: XCTestCase {
 
         do {
             _ = try "&#&#x223E;&#x333;".htmlUnescape(strict: true)
-            XCTAssert(false)
+            XCTFail("Did not throw error")
         }
         catch ParseError.MalformedNumericReference {
             XCTAssert(true)
         }
         catch {
-            XCTAssert(false)
+            XCTFail("Wrong error thrown")
         }
 
         XCTAssertEqual("&#123&#x223E;&#x333;".htmlUnescape(), "{∾̳")
 
         do {
             _ = try "&#123&#x223E;&#x333;".htmlUnescape(strict: true)
-            XCTAssert(false)
+            XCTFail("Did not throw error")
         }
         catch ParseError.MissingSemicolon {
             XCTAssert(true)
         }
         catch {
-            XCTAssert(false)
+            XCTFail("Wrong error thrown")
         }
 
         XCTAssertEqual("&#xABC&#x223E;&#x333;".htmlUnescape(), "઼∾̳")
@@ -335,13 +336,13 @@ class HTMLEntitiesTests: XCTestCase {
 
         do {
             _ = try text.htmlUnescape(strict: true)
-            XCTAssert(false)
+            XCTFail("Did not throw error")
         }
         catch ParseError.MissingSemicolon {
             XCTAssert(true)
         }
         catch {
-            XCTAssert(false)
+            XCTFail("Wrong error thrown")
         }
     }