|
@@ -13,23 +13,17 @@ import XCTest
|
|
class SwiftyMarkdownCharacterTests: XCTestCase {
|
|
class SwiftyMarkdownCharacterTests: XCTestCase {
|
|
|
|
|
|
func testIsolatedCase() {
|
|
func testIsolatedCase() {
|
|
- let challenge = TokenTest(input: "[Link1](http://voyagetravelapps.com/) **bold** [Link2](http://voyagetravelapps.com/)", output: "Link1 bold Link2", tokens: [
|
|
|
|
- Token(type: .string, inputString: "Link1", characterStyles: [CharacterStyle.link]),
|
|
|
|
- Token(type: .string, inputString: " ", characterStyles: []),
|
|
|
|
- Token(type: .string, inputString: "bold", characterStyles: [CharacterStyle.bold]),
|
|
|
|
- Token(type: .string, inputString: " ", characterStyles: []),
|
|
|
|
- Token(type: .string, inputString: "Link2", characterStyles: [CharacterStyle.link])
|
|
|
|
|
|
+ let challenge = TokenTest(input: "\\~\\~removed\\~\\~crossed-out string. ~This should be ignored~", output: "~~removed~~crossed-out string. ~This should be ignored~", tokens: [
|
|
|
|
+ Token(type: .string, inputString: "~~removed~~crossed-out string. ~This should be ignored~", characterStyles: [])
|
|
])
|
|
])
|
|
let results = self.attempt(challenge)
|
|
let results = self.attempt(challenge)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
XCTAssertEqual(results.tokens.map({ $0.outputString }).joined(), challenge.output)
|
|
XCTAssertEqual(results.tokens.map({ $0.outputString }).joined(), challenge.output)
|
|
XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
- XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
|
|
-
|
|
|
|
- }
|
|
|
|
-
|
|
|
|
- func testThatRegularTraitsAreParsedCorrectly() {
|
|
|
|
|
|
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ func testThatBoldTraitsAreRecognised() {
|
|
var challenge = TokenTest(input: "**A bold string**", output: "A bold string", tokens: [
|
|
var challenge = TokenTest(input: "**A bold string**", output: "A bold string", tokens: [
|
|
Token(type: .string, inputString: "A bold string", characterStyles: [CharacterStyle.bold])
|
|
Token(type: .string, inputString: "A bold string", characterStyles: [CharacterStyle.bold])
|
|
])
|
|
])
|
|
@@ -50,8 +44,8 @@ class SwiftyMarkdownCharacterTests: XCTestCase {
|
|
XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
|
|
|
|
- challenge = TokenTest(input: "`Code (**should** not process internal tags)`", output: "Code (**should** not process internal tags)", tokens: [
|
|
|
|
- Token(type: .string, inputString: "Code (**should** not process internal tags) ", characterStyles: [CharacterStyle.code])
|
|
|
|
|
|
+ challenge = TokenTest(input: "\\*\\*A normal string\\*\\*", output: "**A normal string**", tokens: [
|
|
|
|
+ Token(type: .string, inputString: "**A normal string**", characterStyles: [])
|
|
])
|
|
])
|
|
results = self.attempt(challenge)
|
|
results = self.attempt(challenge)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
@@ -59,10 +53,8 @@ class SwiftyMarkdownCharacterTests: XCTestCase {
|
|
XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
|
|
|
|
- challenge = TokenTest(input: "A string with `code` (should not be indented)", output: "A string with code (should not be indented)", tokens : [
|
|
|
|
- Token(type: .string, inputString: "A string with ", characterStyles: []),
|
|
|
|
- Token(type: .string, inputString: "code", characterStyles: [CharacterStyle.code]),
|
|
|
|
- Token(type: .string, inputString: " (should not be indented)", characterStyles: [])
|
|
|
|
|
|
+ challenge = TokenTest(input: "A string with double \\*\\*escaped\\*\\* asterisks", output: "A string with double **escaped** asterisks", tokens: [
|
|
|
|
+ Token(type: .string, inputString: "A string with double **escaped** asterisks", characterStyles: [])
|
|
])
|
|
])
|
|
results = self.attempt(challenge)
|
|
results = self.attempt(challenge)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
@@ -70,8 +62,9 @@ class SwiftyMarkdownCharacterTests: XCTestCase {
|
|
XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
|
|
|
|
- challenge = TokenTest(input: "*An italicised string*", output: "An italicised string", tokens : [
|
|
|
|
- Token(type: .string, inputString: "An italicised string", characterStyles: [CharacterStyle.italic])
|
|
|
|
|
|
+ challenge = TokenTest(input: "\\**One escaped, one not at either end\\**", output: "*One escaped, one not at either end*", tokens: [
|
|
|
|
+ Token(type: .string, inputString: "*", characterStyles: []),
|
|
|
|
+ Token(type: .string, inputString: "One escaped, one not at either end*", characterStyles: [CharacterStyle.italic]),
|
|
])
|
|
])
|
|
results = self.attempt(challenge)
|
|
results = self.attempt(challenge)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
@@ -79,25 +72,32 @@ class SwiftyMarkdownCharacterTests: XCTestCase {
|
|
XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
|
|
|
|
- challenge = TokenTest(input: "A string with *italicised* text", output: "A string with italicised text", tokens : [
|
|
|
|
- Token(type: .string, inputString: "A string with ", characterStyles: []),
|
|
|
|
- Token(type: .string, inputString: "italicised", characterStyles: [CharacterStyle.italic]),
|
|
|
|
- Token(type: .string, inputString: " text", characterStyles: [])
|
|
|
|
|
|
+ challenge = TokenTest(input: "A string with one \\**escaped\\** asterisk, one not at either end", output: "A string with one *escaped* asterisk, one not at either end", tokens: [
|
|
|
|
+ Token(type: .string, inputString: "A string with one *", characterStyles: []),
|
|
|
|
+ Token(type: .string, inputString: "escaped*", characterStyles: [CharacterStyle.italic]),
|
|
|
|
+ Token(type: .string, inputString: " asterisk, one not at either end", characterStyles: [])
|
|
])
|
|
])
|
|
results = self.attempt(challenge)
|
|
results = self.attempt(challenge)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
XCTAssertEqual(results.tokens.map({ $0.outputString }).joined(), challenge.output)
|
|
XCTAssertEqual(results.tokens.map({ $0.outputString }).joined(), challenge.output)
|
|
XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ func testThatCodeTraitsAreRecognised() {
|
|
|
|
+ var challenge = TokenTest(input: "`Code (**should** not process internal tags)`", output: "Code (**should** not process internal tags)", tokens: [
|
|
|
|
+ Token(type: .string, inputString: "Code (**should** not process internal tags) ", characterStyles: [CharacterStyle.code])
|
|
|
|
+ ])
|
|
|
|
+ var results = self.attempt(challenge)
|
|
|
|
+ XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
|
|
+ XCTAssertEqual(results.tokens.map({ $0.outputString }).joined(), challenge.output)
|
|
|
|
+ XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
|
|
+ XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
|
|
|
|
- challenge = TokenTest(input: "__A bold string__ with a **mix** **of** bold __styles__", output: "A bold string with a mix of bold styles", tokens : [
|
|
|
|
- Token(type: .string, inputString: "A bold string", characterStyles: [CharacterStyle.bold]),
|
|
|
|
- Token(type: .string, inputString: "with a ", characterStyles: []),
|
|
|
|
- Token(type: .string, inputString: "mix", characterStyles: [CharacterStyle.bold]),
|
|
|
|
- Token(type: .string, inputString: " ", characterStyles: []),
|
|
|
|
- Token(type: .string, inputString: "of", characterStyles: [CharacterStyle.bold]),
|
|
|
|
- Token(type: .string, inputString: " bold ", characterStyles: []),
|
|
|
|
- Token(type: .string, inputString: "styles", characterStyles: [CharacterStyle.bold])
|
|
|
|
|
|
+ challenge = TokenTest(input: "A string with `code` (should not be indented)", output: "A string with code (should not be indented)", tokens : [
|
|
|
|
+ Token(type: .string, inputString: "A string with ", characterStyles: []),
|
|
|
|
+ Token(type: .string, inputString: "code", characterStyles: [CharacterStyle.code]),
|
|
|
|
+ Token(type: .string, inputString: " (should not be indented)", characterStyles: [])
|
|
])
|
|
])
|
|
results = self.attempt(challenge)
|
|
results = self.attempt(challenge)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
@@ -118,14 +118,8 @@ class SwiftyMarkdownCharacterTests: XCTestCase {
|
|
XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
|
|
|
|
- challenge = TokenTest(input: "_An italic string_ with a *mix* _of_ italic *styles*", output: "An italic string with a mix of italic styles", tokens : [
|
|
|
|
- Token(type: .string, inputString: "An italic string", characterStyles: [CharacterStyle.italic]),
|
|
|
|
- Token(type: .string, inputString: " with a ", characterStyles: []),
|
|
|
|
- Token(type: .string, inputString: "mix", characterStyles: [CharacterStyle.italic]),
|
|
|
|
- Token(type: .string, inputString: " ", characterStyles: []),
|
|
|
|
- Token(type: .string, inputString: "of", characterStyles: [CharacterStyle.italic]),
|
|
|
|
- Token(type: .string, inputString: " italic ", characterStyles: []),
|
|
|
|
- Token(type: .string, inputString: "styles", characterStyles: [CharacterStyle.italic])
|
|
|
|
|
|
+ challenge = TokenTest(input: "\\`A normal string\\`", output: "`A normal string`", tokens: [
|
|
|
|
+ Token(type: .string, inputString: "`A normal string`", characterStyles: [])
|
|
])
|
|
])
|
|
results = self.attempt(challenge)
|
|
results = self.attempt(challenge)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
@@ -133,19 +127,17 @@ class SwiftyMarkdownCharacterTests: XCTestCase {
|
|
XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
|
|
|
|
- challenge = TokenTest(input: "_An italic string_, **follwed by a bold one**, `with some code`, \\*\\*and some\\*\\* \\_escaped\\_ \\`characters\\`, `ending` *with* __more__ variety.", output: "An italic string, follwed by a bold one, with some code, **and some** _escaped_ `characters`, ending with more variety.", tokens : [
|
|
|
|
- Token(type: .string, inputString: "An italic string", characterStyles: [CharacterStyle.italic]),
|
|
|
|
- Token(type: .string, inputString: ", ", characterStyles: []),
|
|
|
|
- Token(type: .string, inputString: "followed by a bold one", characterStyles: [CharacterStyle.bold]),
|
|
|
|
- Token(type: .string, inputString: ", ", characterStyles: []),
|
|
|
|
- Token(type: .string, inputString: "with some code", characterStyles: [CharacterStyle.code]),
|
|
|
|
- Token(type: .string, inputString: ", **and some** _escaped_ `characters`, ", characterStyles: []),
|
|
|
|
- Token(type: .string, inputString: "ending", characterStyles: [CharacterStyle.code]),
|
|
|
|
- Token(type: .string, inputString: " ", characterStyles: []),
|
|
|
|
- Token(type: .string, inputString: "with", characterStyles: [CharacterStyle.italic]),
|
|
|
|
- Token(type: .string, inputString: " ", characterStyles: []),
|
|
|
|
- Token(type: .string, inputString: "more", characterStyles: [CharacterStyle.bold]),
|
|
|
|
- Token(type: .string, inputString: " variety.", characterStyles: [])
|
|
|
|
|
|
+ challenge = TokenTest(input: "A string with \\`escaped\\` backticks", output: "A string with `escaped` backticks", tokens: [
|
|
|
|
+ Token(type: .string, inputString: "A string with `escaped` backticks", characterStyles: [])
|
|
|
|
+ ])
|
|
|
|
+ results = self.attempt(challenge)
|
|
|
|
+ XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
|
|
+ XCTAssertEqual(results.tokens.map({ $0.outputString }).joined(), challenge.output)
|
|
|
|
+ XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
|
|
+ XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
|
|
+
|
|
|
|
+ challenge = TokenTest(input: "A lonely backtick: `", output: "A lonely backtick: `", tokens: [
|
|
|
|
+ Token(type: .string, inputString: "A lonely backtick: `", characterStyles: [])
|
|
])
|
|
])
|
|
results = self.attempt(challenge)
|
|
results = self.attempt(challenge)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
@@ -154,9 +146,10 @@ class SwiftyMarkdownCharacterTests: XCTestCase {
|
|
XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
}
|
|
}
|
|
|
|
|
|
- func testThatExtraCharactersAreHandles() {
|
|
|
|
- var challenge = TokenTest(input: "***A bold italic string***", output: "A bold italic string", tokens: [
|
|
|
|
- Token(type: .string, inputString: "A bold italic string", characterStyles: [CharacterStyle.bold, CharacterStyle.italic])
|
|
|
|
|
|
+ func testThatItalicTraitsAreParsedCorrectly() {
|
|
|
|
+
|
|
|
|
+ var challenge = TokenTest(input: "*An italicised string*", output: "An italicised string", tokens : [
|
|
|
|
+ Token(type: .string, inputString: "An italicised string", characterStyles: [CharacterStyle.italic])
|
|
])
|
|
])
|
|
var results = self.attempt(challenge)
|
|
var results = self.attempt(challenge)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
@@ -164,10 +157,10 @@ class SwiftyMarkdownCharacterTests: XCTestCase {
|
|
XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
|
|
|
|
- challenge = TokenTest(input: "A string with a ****bold italic**** word", output: "A string with a *bold italic* word", tokens: [
|
|
|
|
- Token(type: .string, inputString: "A string with a ", characterStyles: []),
|
|
|
|
- Token(type: .string, inputString: "*bold italic*", characterStyles: [CharacterStyle.bold, CharacterStyle.italic]),
|
|
|
|
- Token(type: .string, inputString: " word", characterStyles: [])
|
|
|
|
|
|
+ challenge = TokenTest(input: "A string with *italicised* text", output: "A string with italicised text", tokens : [
|
|
|
|
+ Token(type: .string, inputString: "A string with ", characterStyles: []),
|
|
|
|
+ Token(type: .string, inputString: "italicised", characterStyles: [CharacterStyle.italic]),
|
|
|
|
+ Token(type: .string, inputString: " text", characterStyles: [])
|
|
])
|
|
])
|
|
results = self.attempt(challenge)
|
|
results = self.attempt(challenge)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
@@ -175,10 +168,15 @@ class SwiftyMarkdownCharacterTests: XCTestCase {
|
|
XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
|
|
|
|
- challenge = TokenTest(input: "A string with a ****bold italic*** word", output: "A string with a *bold italic word", tokens: [
|
|
|
|
- Token(type: .string, inputString: "A string with a ", characterStyles: []),
|
|
|
|
- Token(type: .string, inputString: "*bold italic", characterStyles: [CharacterStyle.bold, CharacterStyle.italic]),
|
|
|
|
- Token(type: .string, inputString: " word", characterStyles: [])
|
|
|
|
|
|
+
|
|
|
|
+ challenge = TokenTest(input: "_An italic string_ with a *mix* _of_ italic *styles*", output: "An italic string with a mix of italic styles", tokens : [
|
|
|
|
+ Token(type: .string, inputString: "An italic string", characterStyles: [CharacterStyle.italic]),
|
|
|
|
+ Token(type: .string, inputString: " with a ", characterStyles: []),
|
|
|
|
+ Token(type: .string, inputString: "mix", characterStyles: [CharacterStyle.italic]),
|
|
|
|
+ Token(type: .string, inputString: " ", characterStyles: []),
|
|
|
|
+ Token(type: .string, inputString: "of", characterStyles: [CharacterStyle.italic]),
|
|
|
|
+ Token(type: .string, inputString: " italic ", characterStyles: []),
|
|
|
|
+ Token(type: .string, inputString: "styles", characterStyles: [CharacterStyle.italic])
|
|
])
|
|
])
|
|
results = self.attempt(challenge)
|
|
results = self.attempt(challenge)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
@@ -186,11 +184,9 @@ class SwiftyMarkdownCharacterTests: XCTestCase {
|
|
XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
|
|
|
|
- challenge = TokenTest(input: "A string with a ***bold** italic* word", output: "A string with a bold italic word", tokens: [
|
|
|
|
- Token(type: .string, inputString: "A string with a ", characterStyles: []),
|
|
|
|
- Token(type: .string, inputString: "bold", characterStyles: [CharacterStyle.bold, CharacterStyle.italic]),
|
|
|
|
- Token(type: .string, inputString: " italic", characterStyles: [CharacterStyle.italic]),
|
|
|
|
- Token(type: .string, inputString: " word", characterStyles: [])
|
|
|
|
|
|
+
|
|
|
|
+ challenge = TokenTest(input: "\\_A normal string\\_", output: "_A normal string_", tokens: [
|
|
|
|
+ Token(type: .string, inputString: "_A normal string_", characterStyles: [])
|
|
])
|
|
])
|
|
results = self.attempt(challenge)
|
|
results = self.attempt(challenge)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
@@ -198,12 +194,8 @@ class SwiftyMarkdownCharacterTests: XCTestCase {
|
|
XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
|
|
|
|
- challenge = TokenTest(input: "A string with a **bold*italic*bold** word", output: "A string with a bolditalicbold word", tokens: [
|
|
|
|
- Token(type: .string, inputString: "A string with a ", characterStyles: []),
|
|
|
|
- Token(type: .string, inputString: "bold", characterStyles: [CharacterStyle.bold]),
|
|
|
|
- Token(type: .string, inputString: "italic", characterStyles: [CharacterStyle.bold, CharacterStyle.italic]),
|
|
|
|
- Token(type: .string, inputString: "bold", characterStyles: [CharacterStyle.bold]),
|
|
|
|
- Token(type: .string, inputString: " word", characterStyles: [])
|
|
|
|
|
|
+ challenge = TokenTest(input: "A string with \\_escaped\\_ underscores", output: "A string with _escaped_ underscores", tokens: [
|
|
|
|
+ Token(type: .string, inputString: "A string with _escaped_ underscores", characterStyles: [])
|
|
])
|
|
])
|
|
results = self.attempt(challenge)
|
|
results = self.attempt(challenge)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
@@ -211,61 +203,108 @@ class SwiftyMarkdownCharacterTests: XCTestCase {
|
|
XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
|
|
|
|
- }
|
|
|
|
-
|
|
|
|
-
|
|
|
|
- // The new version of SwiftyMarkdown is a lot more strict than the old version, although this may change in future
|
|
|
|
- func offtestThatMarkdownMistakesAreHandledAppropriately() {
|
|
|
|
- let mismatchedBoldCharactersAtStart = "**This should be bold*"
|
|
|
|
- let mismatchedBoldCharactersWithin = "A string *that should be italic**"
|
|
|
|
-
|
|
|
|
- var md = SwiftyMarkdown(string: mismatchedBoldCharactersAtStart)
|
|
|
|
- XCTAssertEqual(md.attributedString().string, "This should be bold")
|
|
|
|
-
|
|
|
|
- md = SwiftyMarkdown(string: mismatchedBoldCharactersWithin)
|
|
|
|
- XCTAssertEqual(md.attributedString().string, "A string that should be italic")
|
|
|
|
|
|
+ challenge = TokenTest(input: """
|
|
|
|
+ An asterisk: *
|
|
|
|
+ Line break
|
|
|
|
+ """, output: """
|
|
|
|
+ An asterisk: *
|
|
|
|
+ Line break
|
|
|
|
+ """, tokens: [
|
|
|
|
+ Token(type: .string, inputString: "An asterisk: *", characterStyles: []),
|
|
|
|
+ Token(type: .string, inputString: "Line break", characterStyles: [])
|
|
|
|
+ ])
|
|
|
|
+ results = self.attempt(challenge)
|
|
|
|
+ XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
|
|
+ XCTAssertEqual(results.tokens.map({ $0.outputString }).joined(), challenge.output)
|
|
|
|
+ XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
|
|
+ XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
|
|
|
|
}
|
|
}
|
|
|
|
|
|
- func testThatEscapedCharactersAreEscapedCorrectly() {
|
|
|
|
- var challenge = TokenTest(input: "\\*\\*A normal string\\*\\*", output: "**A normal string**", tokens: [
|
|
|
|
- Token(type: .string, inputString: "**A normal string**", characterStyles: [])
|
|
|
|
|
|
+ func testThatStrikethroughTraitsAreRecognised() {
|
|
|
|
+ var challenge = TokenTest(input: "~~An~~A crossed-out string", output: "AnA crossed-out string", tokens: [
|
|
|
|
+ Token(type: .string, inputString: "An", characterStyles: [CharacterStyle.strikethrough]),
|
|
|
|
+ Token(type: .string, inputString: "A crossed-out string", characterStyles: [])
|
|
])
|
|
])
|
|
var results = self.attempt(challenge)
|
|
var results = self.attempt(challenge)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
XCTAssertEqual(results.tokens.map({ $0.outputString }).joined(), challenge.output)
|
|
XCTAssertEqual(results.tokens.map({ $0.outputString }).joined(), challenge.output)
|
|
XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
- XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
|
|
|
|
|
|
- challenge = TokenTest(input: "A string with double \\*\\*escaped\\*\\* asterisks", output: "A string with double **escaped** asterisks", tokens: [
|
|
|
|
- Token(type: .string, inputString: "A string with double **escaped** asterisks", characterStyles: [])
|
|
|
|
|
|
+ challenge = TokenTest(input: "A **Bold** string and a ~~removed~~crossed-out string", output: "A Bold string and a removedcrossed-out string", tokens: [
|
|
|
|
+ Token(type: .string, inputString: "A ", characterStyles: []),
|
|
|
|
+ Token(type: .string, inputString: "Bold", characterStyles: [CharacterStyle.bold]),
|
|
|
|
+ Token(type: .string, inputString: " string and a ", characterStyles: []),
|
|
|
|
+ Token(type: .string, inputString: "removed", characterStyles: [CharacterStyle.strikethrough]),
|
|
|
|
+ Token(type: .string, inputString: "crossed-out string", characterStyles: [])
|
|
])
|
|
])
|
|
results = self.attempt(challenge)
|
|
results = self.attempt(challenge)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
XCTAssertEqual(results.tokens.map({ $0.outputString }).joined(), challenge.output)
|
|
XCTAssertEqual(results.tokens.map({ $0.outputString }).joined(), challenge.output)
|
|
XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
- XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
|
|
|
|
|
|
- challenge = TokenTest(input: "\\_A normal string\\_", output: "_A normal string_", tokens: [
|
|
|
|
- Token(type: .string, inputString: "_A normal string_", characterStyles: [])
|
|
|
|
|
|
+ challenge = TokenTest(input: "\\~\\~removed\\~\\~crossed-out string. ~This should be ignored~", output: "~~removed~~crossed-out string. ~This should be ignored~", tokens: [
|
|
|
|
+ Token(type: .string, inputString: "~~removed~~crossed-out string. ~This should be ignored~", characterStyles: [])
|
|
])
|
|
])
|
|
results = self.attempt(challenge)
|
|
results = self.attempt(challenge)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
XCTAssertEqual(results.tokens.map({ $0.outputString }).joined(), challenge.output)
|
|
XCTAssertEqual(results.tokens.map({ $0.outputString }).joined(), challenge.output)
|
|
XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
|
|
+
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ func testThatMixedTraitsAreRecognised() {
|
|
|
|
+
|
|
|
|
+ var challenge = TokenTest(input: "__A bold string__ with a **mix** **of** bold __styles__", output: "A bold string with a mix of bold styles", tokens : [
|
|
|
|
+ Token(type: .string, inputString: "A bold string", characterStyles: [CharacterStyle.bold]),
|
|
|
|
+ Token(type: .string, inputString: "with a ", characterStyles: []),
|
|
|
|
+ Token(type: .string, inputString: "mix", characterStyles: [CharacterStyle.bold]),
|
|
|
|
+ Token(type: .string, inputString: " ", characterStyles: []),
|
|
|
|
+ Token(type: .string, inputString: "of", characterStyles: [CharacterStyle.bold]),
|
|
|
|
+ Token(type: .string, inputString: " bold ", characterStyles: []),
|
|
|
|
+ Token(type: .string, inputString: "styles", characterStyles: [CharacterStyle.bold])
|
|
|
|
+ ])
|
|
|
|
+ var results = self.attempt(challenge)
|
|
|
|
+ XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
|
|
+ XCTAssertEqual(results.tokens.map({ $0.outputString }).joined(), challenge.output)
|
|
|
|
+ XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
|
|
|
|
- challenge = TokenTest(input: "A string with \\_escaped\\_ underscores", output: "A string with _escaped_ underscores", tokens: [
|
|
|
|
- Token(type: .string, inputString: "A string with _escaped_ underscores", characterStyles: [])
|
|
|
|
|
|
+ challenge = TokenTest(input: "_An italic string_, **follwed by a bold one**, `with some code`, \\*\\*and some\\*\\* \\_escaped\\_ \\`characters\\`, `ending` *with* __more__ variety.", output: "An italic string, follwed by a bold one, with some code, **and some** _escaped_ `characters`, ending with more variety.", tokens : [
|
|
|
|
+ Token(type: .string, inputString: "An italic string", characterStyles: [CharacterStyle.italic]),
|
|
|
|
+ Token(type: .string, inputString: ", ", characterStyles: []),
|
|
|
|
+ Token(type: .string, inputString: "followed by a bold one", characterStyles: [CharacterStyle.bold]),
|
|
|
|
+ Token(type: .string, inputString: ", ", characterStyles: []),
|
|
|
|
+ Token(type: .string, inputString: "with some code", characterStyles: [CharacterStyle.code]),
|
|
|
|
+ Token(type: .string, inputString: ", **and some** _escaped_ `characters`, ", characterStyles: []),
|
|
|
|
+ Token(type: .string, inputString: "ending", characterStyles: [CharacterStyle.code]),
|
|
|
|
+ Token(type: .string, inputString: " ", characterStyles: []),
|
|
|
|
+ Token(type: .string, inputString: "with", characterStyles: [CharacterStyle.italic]),
|
|
|
|
+ Token(type: .string, inputString: " ", characterStyles: []),
|
|
|
|
+ Token(type: .string, inputString: "more", characterStyles: [CharacterStyle.bold]),
|
|
|
|
+ Token(type: .string, inputString: " variety.", characterStyles: [])
|
|
])
|
|
])
|
|
results = self.attempt(challenge)
|
|
results = self.attempt(challenge)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
XCTAssertEqual(results.tokens.map({ $0.outputString }).joined(), challenge.output)
|
|
XCTAssertEqual(results.tokens.map({ $0.outputString }).joined(), challenge.output)
|
|
XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ func testThatExtraCharactersAreHandles() {
|
|
|
|
+ var challenge = TokenTest(input: "***A bold italic string***", output: "A bold italic string", tokens: [
|
|
|
|
+ Token(type: .string, inputString: "A bold italic string", characterStyles: [CharacterStyle.bold, CharacterStyle.italic])
|
|
|
|
+ ])
|
|
|
|
+ var results = self.attempt(challenge)
|
|
|
|
+ XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
|
|
+ XCTAssertEqual(results.tokens.map({ $0.outputString }).joined(), challenge.output)
|
|
|
|
+ XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
|
|
+ XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
|
|
|
|
- challenge = TokenTest(input: "\\`A normal string\\`", output: "`A normal string`", tokens: [
|
|
|
|
- Token(type: .string, inputString: "`A normal string`", characterStyles: [])
|
|
|
|
|
|
+ challenge = TokenTest(input: "A string with a ****bold italic**** word", output: "A string with a *bold italic* word", tokens: [
|
|
|
|
+ Token(type: .string, inputString: "A string with a ", characterStyles: []),
|
|
|
|
+ Token(type: .string, inputString: "*bold italic*", characterStyles: [CharacterStyle.bold, CharacterStyle.italic]),
|
|
|
|
+ Token(type: .string, inputString: " word", characterStyles: [])
|
|
])
|
|
])
|
|
results = self.attempt(challenge)
|
|
results = self.attempt(challenge)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
@@ -273,8 +312,10 @@ class SwiftyMarkdownCharacterTests: XCTestCase {
|
|
XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
|
|
|
|
- challenge = TokenTest(input: "A string with \\`escaped\\` backticks", output: "A string with `escaped` backticks", tokens: [
|
|
|
|
- Token(type: .string, inputString: "A string with `escaped` backticks", characterStyles: [])
|
|
|
|
|
|
+ challenge = TokenTest(input: "A string with a ****bold italic*** word", output: "A string with a *bold italic word", tokens: [
|
|
|
|
+ Token(type: .string, inputString: "A string with a ", characterStyles: []),
|
|
|
|
+ Token(type: .string, inputString: "*bold italic", characterStyles: [CharacterStyle.bold, CharacterStyle.italic]),
|
|
|
|
+ Token(type: .string, inputString: " word", characterStyles: [])
|
|
])
|
|
])
|
|
results = self.attempt(challenge)
|
|
results = self.attempt(challenge)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
@@ -282,9 +323,11 @@ class SwiftyMarkdownCharacterTests: XCTestCase {
|
|
XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
|
|
|
|
- challenge = TokenTest(input: "\\**One escaped, one not at either end\\**", output: "*One escaped, one not at either end*", tokens: [
|
|
|
|
- Token(type: .string, inputString: "*", characterStyles: []),
|
|
|
|
- Token(type: .string, inputString: "One escaped, one not at either end*", characterStyles: [CharacterStyle.italic]),
|
|
|
|
|
|
+ challenge = TokenTest(input: "A string with a ***bold** italic* word", output: "A string with a bold italic word", tokens: [
|
|
|
|
+ Token(type: .string, inputString: "A string with a ", characterStyles: []),
|
|
|
|
+ Token(type: .string, inputString: "bold", characterStyles: [CharacterStyle.bold, CharacterStyle.italic]),
|
|
|
|
+ Token(type: .string, inputString: " italic", characterStyles: [CharacterStyle.italic]),
|
|
|
|
+ Token(type: .string, inputString: " word", characterStyles: [])
|
|
])
|
|
])
|
|
results = self.attempt(challenge)
|
|
results = self.attempt(challenge)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
@@ -292,10 +335,12 @@ class SwiftyMarkdownCharacterTests: XCTestCase {
|
|
XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
|
|
|
|
- challenge = TokenTest(input: "A string with one \\**escaped\\** asterisk, one not at either end", output: "A string with one *escaped* asterisk, one not at either end", tokens: [
|
|
|
|
- Token(type: .string, inputString: "A string with one *", characterStyles: []),
|
|
|
|
- Token(type: .string, inputString: "escaped*", characterStyles: [CharacterStyle.italic]),
|
|
|
|
- Token(type: .string, inputString: " asterisk, one not at either end", characterStyles: [])
|
|
|
|
|
|
+ challenge = TokenTest(input: "A string with a **bold*italic*bold** word", output: "A string with a bolditalicbold word", tokens: [
|
|
|
|
+ Token(type: .string, inputString: "A string with a ", characterStyles: []),
|
|
|
|
+ Token(type: .string, inputString: "bold", characterStyles: [CharacterStyle.bold]),
|
|
|
|
+ Token(type: .string, inputString: "italic", characterStyles: [CharacterStyle.bold, CharacterStyle.italic]),
|
|
|
|
+ Token(type: .string, inputString: "bold", characterStyles: [CharacterStyle.bold]),
|
|
|
|
+ Token(type: .string, inputString: " word", characterStyles: [])
|
|
])
|
|
])
|
|
results = self.attempt(challenge)
|
|
results = self.attempt(challenge)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
@@ -305,6 +350,20 @@ class SwiftyMarkdownCharacterTests: XCTestCase {
|
|
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
+
|
|
|
|
+ // The new version of SwiftyMarkdown is a lot more strict than the old version, although this may change in future
|
|
|
|
+ func offtestThatMarkdownMistakesAreHandledAppropriately() {
|
|
|
|
+ let mismatchedBoldCharactersAtStart = "**This should be bold*"
|
|
|
|
+ let mismatchedBoldCharactersWithin = "A string *that should be italic**"
|
|
|
|
+
|
|
|
|
+ var md = SwiftyMarkdown(string: mismatchedBoldCharactersAtStart)
|
|
|
|
+ XCTAssertEqual(md.attributedString().string, "This should be bold")
|
|
|
|
+
|
|
|
|
+ md = SwiftyMarkdown(string: mismatchedBoldCharactersWithin)
|
|
|
|
+ XCTAssertEqual(md.attributedString().string, "A string that should be italic")
|
|
|
|
+
|
|
|
|
+ }
|
|
|
|
+
|
|
func offtestAdvancedEscaping() {
|
|
func offtestAdvancedEscaping() {
|
|
|
|
|
|
var challenge = TokenTest(input: "\\***A normal string*\\**", output: "**A normal string*", tokens: [
|
|
var challenge = TokenTest(input: "\\***A normal string*\\**", output: "**A normal string*", tokens: [
|
|
@@ -331,29 +390,24 @@ class SwiftyMarkdownCharacterTests: XCTestCase {
|
|
}
|
|
}
|
|
|
|
|
|
func testThatAsterisksAndUnderscoresNotAttachedToWordsAreNotRemoved() {
|
|
func testThatAsterisksAndUnderscoresNotAttachedToWordsAreNotRemoved() {
|
|
- let asteriskSpace = """
|
|
|
|
- An asterisk followed by a space: *
|
|
|
|
- Line break
|
|
|
|
- """
|
|
|
|
- let backtickSpace = "A backtick followed by a space: `"
|
|
|
|
- let underscoreSpace = "An underscore followed by a space: _"
|
|
|
|
|
|
|
|
let asteriskFullStop = "Two asterisks followed by a full stop: **."
|
|
let asteriskFullStop = "Two asterisks followed by a full stop: **."
|
|
- let backtickFullStop = "Two backticks followed by a full stop: ``."
|
|
|
|
|
|
+ let asteriskWithBold = "A **bold** word followed by an asterisk * "
|
|
let underscoreFullStop = "Two underscores followed by a full stop: __."
|
|
let underscoreFullStop = "Two underscores followed by a full stop: __."
|
|
-
|
|
|
|
let asteriskComma = "An asterisk followed by a full stop: *, *"
|
|
let asteriskComma = "An asterisk followed by a full stop: *, *"
|
|
|
|
+
|
|
|
|
+ let backtickSpace = "A backtick followed by a space: `"
|
|
|
|
+ let backtickFullStop = "Two backticks followed by a full stop: ``."
|
|
|
|
+
|
|
|
|
+ let underscoreSpace = "An underscore followed by a space: _"
|
|
|
|
+
|
|
let backtickComma = "A backtick followed by a space: `, `"
|
|
let backtickComma = "A backtick followed by a space: `, `"
|
|
let underscoreComma = "An underscore followed by a space: _, _"
|
|
let underscoreComma = "An underscore followed by a space: _, _"
|
|
|
|
|
|
- let asteriskWithBold = "A **bold** word followed by an asterisk * "
|
|
|
|
let backtickWithCode = "A `code` word followed by a backtick ` "
|
|
let backtickWithCode = "A `code` word followed by a backtick ` "
|
|
let underscoreWithItalic = "An _italic_ word followed by an underscore _ "
|
|
let underscoreWithItalic = "An _italic_ word followed by an underscore _ "
|
|
|
|
|
|
- var md = SwiftyMarkdown(string: asteriskSpace)
|
|
|
|
- XCTAssertEqual(md.attributedString().string, asteriskSpace)
|
|
|
|
-
|
|
|
|
- md = SwiftyMarkdown(string: backtickSpace)
|
|
|
|
|
|
+ var md = SwiftyMarkdown(string: backtickSpace)
|
|
XCTAssertEqual(md.attributedString().string, backtickSpace)
|
|
XCTAssertEqual(md.attributedString().string, backtickSpace)
|
|
|
|
|
|
md = SwiftyMarkdown(string: underscoreSpace)
|
|
md = SwiftyMarkdown(string: underscoreSpace)
|
|
@@ -389,191 +443,5 @@ class SwiftyMarkdownCharacterTests: XCTestCase {
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
- func testForLinks() {
|
|
|
|
-
|
|
|
|
- var challenge = TokenTest(input: "[Link at start](http://voyagetravelapps.com/)", output: "Link at start", tokens: [
|
|
|
|
- Token(type: .string, inputString: "Link at start", characterStyles: [CharacterStyle.link])
|
|
|
|
- ])
|
|
|
|
- var results = self.attempt(challenge)
|
|
|
|
- XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
|
|
- XCTAssertEqual(results.tokens.map({ $0.outputString }).joined(), challenge.output)
|
|
|
|
- XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
|
|
- XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
|
|
- if let existentOpen = results.tokens.filter({ $0.type == .string && (($0.characterStyles as? [CharacterStyle])?.contains(.link) ?? false) }).first {
|
|
|
|
- XCTAssertEqual(existentOpen.metadataString, "http://voyagetravelapps.com/")
|
|
|
|
- } else {
|
|
|
|
- XCTFail("Failed to find an open link tag")
|
|
|
|
- }
|
|
|
|
-
|
|
|
|
-
|
|
|
|
- challenge = TokenTest(input: "A [Link](http://voyagetravelapps.com/)", output: "A Link", tokens: [
|
|
|
|
- Token(type: .string, inputString: "A ", characterStyles: []),
|
|
|
|
- Token(type: .string, inputString: "Link", characterStyles: [CharacterStyle.link])
|
|
|
|
- ])
|
|
|
|
- results = self.attempt(challenge)
|
|
|
|
- XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
|
|
- XCTAssertEqual(results.tokens.map({ $0.outputString }).joined(), challenge.output)
|
|
|
|
- XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
|
|
- XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
|
|
-
|
|
|
|
-
|
|
|
|
- challenge = TokenTest(input: "[Link 1](http://voyagetravelapps.com/), [Link 2](https://www.neverendingvoyage.com/)", output: "Link 1, Link 2", tokens: [
|
|
|
|
- Token(type: .string, inputString: "Link 1", characterStyles: [CharacterStyle.link]),
|
|
|
|
- Token(type: .string, inputString: ", ", characterStyles: []),
|
|
|
|
- Token(type: .string, inputString: "Link 2", characterStyles: [CharacterStyle.link])
|
|
|
|
- ])
|
|
|
|
-
|
|
|
|
- results = self.attempt(challenge)
|
|
|
|
- XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
|
|
- XCTAssertEqual(results.tokens.map({ $0.outputString }).joined(), challenge.output)
|
|
|
|
- XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
|
|
- XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
|
|
- var links = results.tokens.filter({ $0.type == .string && (($0.characterStyles as? [CharacterStyle])?.contains(.link) ?? false) })
|
|
|
|
- XCTAssertEqual(links.count, 2)
|
|
|
|
- XCTAssertEqual(links[0].metadataString, "http://voyagetravelapps.com/")
|
|
|
|
- XCTAssertEqual(links[1].metadataString, "https://www.neverendingvoyage.com/")
|
|
|
|
-
|
|
|
|
- challenge = TokenTest(input: "Email us at [simon@voyagetravelapps.com](mailto:simon@voyagetravelapps.com) Twitter [@VoyageTravelApp](twitter://user?screen_name=VoyageTravelApp)", output: "Email us at simon@voyagetravelapps.com Twitter @VoyageTravelApp", tokens: [
|
|
|
|
- Token(type: .string, inputString: "Email us at ", characterStyles: []),
|
|
|
|
- Token(type: .string, inputString: "simon@voyagetravelapps.com", characterStyles: [CharacterStyle.link]),
|
|
|
|
- Token(type: .string, inputString: " Twitter", characterStyles: []),
|
|
|
|
- Token(type: .string, inputString: "@VoyageTravelApp", characterStyles: [CharacterStyle.link])
|
|
|
|
- ])
|
|
|
|
-
|
|
|
|
- results = self.attempt(challenge)
|
|
|
|
- XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
|
|
- XCTAssertEqual(results.tokens.map({ $0.outputString }).joined(), challenge.output)
|
|
|
|
- XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
|
|
- XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
|
|
- links = results.tokens.filter({ $0.type == .string && (($0.characterStyles as? [CharacterStyle])?.contains(.link) ?? false) })
|
|
|
|
- XCTAssertEqual(links.count, 2)
|
|
|
|
- XCTAssertEqual(links[0].metadataString, "mailto:simon@voyagetravelapps.com")
|
|
|
|
- XCTAssertEqual(links[1].metadataString, "twitter://user?screen_name=VoyageTravelApp")
|
|
|
|
-
|
|
|
|
- challenge = TokenTest(input: "[Link with missing square(http://voyagetravelapps.com/)", output: "[Link with missing square(http://voyagetravelapps.com/)", tokens: [
|
|
|
|
- Token(type: .string, inputString: "Link with missing square(http://voyagetravelapps.com/)", characterStyles: [])
|
|
|
|
- ])
|
|
|
|
- results = self.attempt(challenge)
|
|
|
|
- XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
|
|
- XCTAssertEqual(results.tokens.map({ $0.outputString }).joined(), challenge.output)
|
|
|
|
- XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
|
|
- XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
|
|
-
|
|
|
|
- challenge = TokenTest(input: "A [Link(http://voyagetravelapps.com/)", output: "A [Link(http://voyagetravelapps.com/)", tokens: [
|
|
|
|
- Token(type: .string, inputString: "A ", characterStyles: []),
|
|
|
|
- Token(type: .string, inputString: "[Link(http://voyagetravelapps.com/)", characterStyles: [])
|
|
|
|
- ])
|
|
|
|
- results = self.attempt(challenge)
|
|
|
|
- XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
|
|
- XCTAssertEqual(results.tokens.map({ $0.outputString }).joined(), challenge.output)
|
|
|
|
- XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
|
|
- XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
|
|
-
|
|
|
|
-
|
|
|
|
- challenge = TokenTest(input: "[Link with missing parenthesis](http://voyagetravelapps.com/", output: "[Link with missing parenthesis](http://voyagetravelapps.com/", tokens: [
|
|
|
|
- Token(type: .string, inputString: "[Link with missing parenthesis](", characterStyles: []),
|
|
|
|
- Token(type: .string, inputString: "http://voyagetravelapps.com/", characterStyles: [])
|
|
|
|
- ])
|
|
|
|
- results = self.attempt(challenge)
|
|
|
|
- XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
|
|
- XCTAssertEqual(results.tokens.map({ $0.outputString }).joined(), challenge.output)
|
|
|
|
- XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
|
|
- XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
|
|
-
|
|
|
|
- challenge = TokenTest(input: "A [Link](http://voyagetravelapps.com/", output: "A [Link](http://voyagetravelapps.com/", tokens: [
|
|
|
|
- Token(type: .string, inputString: "A ", characterStyles: []),
|
|
|
|
- Token(type: .string, inputString: "[Link](", characterStyles: []),
|
|
|
|
- Token(type: .string, inputString: "http://voyagetravelapps.com/", characterStyles: [])
|
|
|
|
- ])
|
|
|
|
- results = self.attempt(challenge)
|
|
|
|
- XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
|
|
- XCTAssertEqual(results.tokens.map({ $0.outputString }).joined(), challenge.output)
|
|
|
|
- XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
|
|
- XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
|
|
-
|
|
|
|
- challenge = TokenTest(input: "[Link1](http://voyagetravelapps.com/) **bold** [Link2](http://voyagetravelapps.com/)", output: "Link1 bold Link2", tokens: [
|
|
|
|
- Token(type: .string, inputString: "Link1", characterStyles: [CharacterStyle.link]),
|
|
|
|
- Token(type: .string, inputString: " ", characterStyles: []),
|
|
|
|
- Token(type: .string, inputString: "bold", characterStyles: [CharacterStyle.bold]),
|
|
|
|
- Token(type: .string, inputString: " ", characterStyles: []),
|
|
|
|
- Token(type: .string, inputString: "Link2", characterStyles: [CharacterStyle.link])
|
|
|
|
- ])
|
|
|
|
- results = self.attempt(challenge)
|
|
|
|
- XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
|
|
- XCTAssertEqual(results.tokens.map({ $0.outputString }).joined(), challenge.output)
|
|
|
|
- XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
|
|
- XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
|
|
-
|
|
|
|
- }
|
|
|
|
-
|
|
|
|
- func testLinksWithOtherStyles() {
|
|
|
|
- var challenge = TokenTest(input: "A **Bold [Link](http://voyagetravelapps.com/)**", output: "A Bold Link", tokens: [
|
|
|
|
- Token(type: .string, inputString: "A ", characterStyles: []),
|
|
|
|
- Token(type: .string, inputString: "Bold ", characterStyles: [CharacterStyle.bold]),
|
|
|
|
- Token(type: .string, inputString: "Link", characterStyles: [CharacterStyle.link, CharacterStyle.bold])
|
|
|
|
- ])
|
|
|
|
- var results = self.attempt(challenge)
|
|
|
|
- XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
|
|
- XCTAssertEqual(results.tokens.map({ $0.outputString }).joined(), challenge.output)
|
|
|
|
- XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
|
|
-// XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
|
|
- var links = results.tokens.filter({ $0.type == .string && (($0.characterStyles as? [CharacterStyle])?.contains(.link) ?? false) })
|
|
|
|
- XCTAssertEqual(links.count, 1)
|
|
|
|
- if links.count == 1 {
|
|
|
|
- XCTAssertEqual(links[0].metadataString, "http://voyagetravelapps.com/")
|
|
|
|
- } else {
|
|
|
|
- XCTFail("Incorrect link count. Expecting 1, found \(links.count)")
|
|
|
|
- }
|
|
|
|
-
|
|
|
|
- challenge = TokenTest(input: "A Bold [**Link**](http://voyagetravelapps.com/)", output: "A Bold Link", tokens: [
|
|
|
|
- Token(type: .string, inputString: "A Bold ", characterStyles: []),
|
|
|
|
- Token(type: .string, inputString: "Link", characterStyles: [CharacterStyle.bold, CharacterStyle.link])
|
|
|
|
- ])
|
|
|
|
- results = self.attempt(challenge)
|
|
|
|
- XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
|
|
- XCTAssertEqual(results.tokens.map({ $0.outputString }).joined(), challenge.output)
|
|
|
|
- XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
|
|
- XCTAssertEqual(results.attributedString.string, challenge.output)
|
|
|
|
- links = results.tokens.filter({ $0.type == .string && (($0.characterStyles as? [CharacterStyle])?.contains(.link) ?? false) })
|
|
|
|
- XCTAssertEqual(links.count, 1)
|
|
|
|
- XCTAssertEqual(links[0].metadataString, "http://voyagetravelapps.com/")
|
|
|
|
- }
|
|
|
|
-
|
|
|
|
- func testForImages() {
|
|
|
|
- let challenge = TokenTest(input: "An ", output: "An Image", tokens: [
|
|
|
|
- Token(type: .string, inputString: "An Image", characterStyles: []),
|
|
|
|
- Token(type: .string, inputString: "", characterStyles: [CharacterStyle.image])
|
|
|
|
- ])
|
|
|
|
- let results = self.attempt(challenge)
|
|
|
|
- XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
|
|
- XCTAssertEqual(results.tokens.map({ $0.outputString }).joined(), challenge.output)
|
|
|
|
- XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
|
|
- let links = results.tokens.filter({ $0.type == .string && (($0.characterStyles as? [CharacterStyle])?.contains(.image) ?? false) })
|
|
|
|
- XCTAssertEqual(links.count, 1)
|
|
|
|
- XCTAssertEqual(links[0].metadataString, "imageName")
|
|
|
|
- }
|
|
|
|
|
|
|
|
- func testForStrikethrough() {
|
|
|
|
- var challenge = TokenTest(input: "~~An~~A crossed-out string", output: "AnA crossed-out string", tokens: [
|
|
|
|
- Token(type: .string, inputString: "An", characterStyles: [CharacterStyle.strikethrough]),
|
|
|
|
- Token(type: .string, inputString: "A crossed-out string", characterStyles: [])
|
|
|
|
- ])
|
|
|
|
- var results = self.attempt(challenge)
|
|
|
|
- XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
|
|
- XCTAssertEqual(results.tokens.map({ $0.outputString }).joined(), challenge.output)
|
|
|
|
- XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
|
|
-
|
|
|
|
- challenge = TokenTest(input: "A **Bold** string and a ~~removed~~crossed-out string", output: "A Bold string and a removedcrossed-out string", tokens: [
|
|
|
|
- Token(type: .string, inputString: "A ", characterStyles: []),
|
|
|
|
- Token(type: .string, inputString: "Bold", characterStyles: [CharacterStyle.bold]),
|
|
|
|
- Token(type: .string, inputString: " string and a ", characterStyles: []),
|
|
|
|
- Token(type: .string, inputString: "removed", characterStyles: [CharacterStyle.strikethrough]),
|
|
|
|
- Token(type: .string, inputString: "crossed-out string", characterStyles: [])
|
|
|
|
- ])
|
|
|
|
- results = self.attempt(challenge)
|
|
|
|
- XCTAssertEqual(challenge.tokens.count, results.stringTokens.count)
|
|
|
|
- XCTAssertEqual(results.tokens.map({ $0.outputString }).joined(), challenge.output)
|
|
|
|
- XCTAssertEqual(results.foundStyles, results.expectedStyles)
|
|
|
|
-
|
|
|
|
- }
|
|
|
|
}
|
|
}
|