         let failing = ["/*",
                        ]
         XCTAssertNoThrow(try checkSimplePassFail(for: .startRegex, passing: passing, failing: failing, expectNode: false))
+        do {
+            let token = STLRTokens.startRegex
+            _ = try makeAST(for: token, from: "/")
+            XCTFail("Should have thrown no nodes")
+        } catch {
+        }
     }
     
     func testEndRegex(){

        let failing = ["2a"]
        
        XCTAssertNoThrow(try checkSimplePassFail(for: .element, passing: passing, failing: failing, expectNode: true))
        #warning("Check strucure and errors")
    }
    
    func testAssignmentOperators(){
        XCTAssertNoThrow(try checkSimplePassFail(for: .assignmentOperators, passing: ["=","+=","|="], failing: [""], expectNode: true))
    }

    func testOr(){
        XCTAssertNoThrow(try checkSimplePassFail(for: .or, passing: ["|"," |","| "," | ","  |    "], failing: [""], expectNode: false))
    }

    func testThen(){
        XCTAssertNoThrow(try checkSimplePassFail(for: .then, passing: ["+"," +","+ "," + ","  +    "], failing: [""], expectNode: false))
    }

    func testChoice(){
        XCTAssertNoThrow(try checkSimplePassFail(for: .choice, passing: ["a | b","a|b | c","a | b  //Comment\n|c"], failing: [""], expectNode: true))
        #warning("Test structure")
    }

    func testSequence(){
        XCTAssertNoThrow(try checkSimplePassFail(for: .sequence, passing: ["a  b","a b   c","a   b\nc //Comment"], failing: [""], expectNode: true))
        #warning("Test structure")
    }
    
    func testNotNewRule(){
        XCTAssertNoThrow(try checkSimplePassFail(for: .notNewRule, passing: ["a : something"], failing: ["a = b"], expectNode: false))
    }
    
    func testExpression(){
        XCTAssertNoThrow(try checkSimplePassFail(for: .expression, passing: ["a","a | b","a b"], failing: [""], expectNode: true))
        #warning("Test structure")
    }
    
    func testStandardType(){
        XCTAssertNoThrow(try checkSimplePassFail(for: .standardType, passing: ["Bool","Int","String","Double"], failing: [""], expectNode: true))
    }

    func testCustomType(){
        XCTAssertNoThrow(try checkSimplePassFail(for: .customType, passing: ["Mine","_mine","Min_","Min3"], failing: ["3","min"], expectNode: true))
    }

    func testTokenType(){
        XCTAssertNoThrow(try checkSimplePassFail(for: .tokenType, passing: ["Bool","Mine"], failing: ["bool","mine"], expectNode: true))
        #warning("Test structure")
    }

    func testLHS(){

        let failing = [""]
        
        XCTAssertNoThrow(try checkSimplePassFail(for: .terminal, passing: passing, failing: failing, expectNode: true))

        XCTAssertNoThrow(try checkSimplePassFail(for: .terminal, passing: ["/regex/ "], failing: failing, expectNode: true, appendMopUpRule:" "))
        
        do {
            let token = STLRTokens.terminal
            let ast = try makeAST(for: token, from: ".letter\"something\"\"a\"...\"b\"")
            var childMatches = [STLRTokens.characterSet,STLRTokens.terminalString,STLRTokens.characterRange]
            XCTAssertEqual(childMatches.count, ast.children.count)
            for child in ast.children {
                XCTAssertEqual(token, child.token as! STLRTokens)
                for specificType in child.children{
                    XCTAssertEqual(childMatches.removeFirst(), specificType.token as! STLRTokens)
                }
            }
        } catch {
            XCTFail("\(error)")
        }

    }
    
    func testAnnotation(){
        let passing = ["@void","@wibble(3)","@token(\"4\")"]
        XCTAssertNoThrow(try checkSimplePassFail(for: .annotation, passing: passing, failing: ["@","@3","@something(","@something(2"], expectNode: true))
        do {
            let token = STLRTokens.annotation
            let ast = try makeAST(for: token, from: "@void(3)")
            var childMatches = [STLRTokens.label,STLRTokens.literal]
            XCTAssertEqual(childMatches.count, ast.children.count)
            XCTAssertEqual(token, ast.token as! STLRTokens)

            for child in ast.children {
                XCTAssertEqual(childMatches.removeFirst(), child.token as! STLRTokens)
            }
        } catch {
            XCTFail("\(error)")
        }
    }
    
    func testAnnotations(){
