How to use SubscriptDeclaration class

...12*/13import XCTest14@testable import AST15@testable import Parser16class ParserSubscriptDeclarationTests: XCTestCase {17  func testSubscriptDecl() {18    parseDeclarationAndTest("subscript() -> Self {}", "subscript() -> Self {}", testClosure: { decl in19      guard let subscriptDecl = decl as? SubscriptDeclaration else {20        XCTFail("Failed in getting a subscript declaration.")21        return22      }23      XCTAssertTrue(subscriptDecl.attributes.isEmpty)24      XCTAssertTrue(subscriptDecl.modifiers.isEmpty)25      XCTAssertNil(subscriptDecl.genericParameterClause)26      XCTAssertTrue(subscriptDecl.parameterList.isEmpty)27      XCTAssertTrue(subscriptDecl.resultAttributes.isEmpty)28      XCTAssertTrue(subscriptDecl.resultType is SelfType)29      XCTAssertNil(subscriptDecl.genericWhereClause)30      guard case let .codeBlock(codeBlock) = subscriptDecl.body else {31        XCTFail("Failed in getting a code block for subscript declaration.")32        return33      }34      XCTAssertTrue(codeBlock.statements.isEmpty)35    })36  }37  func testAttributes() {38    parseDeclarationAndTest("@a subscript() -> Self {}", "@a subscript() -> Self {}", testClosure: { decl in39      guard let subscriptDecl = decl as? SubscriptDeclaration else {40        XCTFail("Failed in getting a subscript declaration.")41        return42      }43      XCTAssertEqual(subscriptDecl.attributes.count, 1)44      XCTAssertEqual(subscriptDecl.attributes[0].name.textDescription, "a")45      XCTAssertTrue(subscriptDecl.modifiers.isEmpty)46      XCTAssertTrue(subscriptDecl.parameterList.isEmpty)47      XCTAssertTrue(subscriptDecl.resultAttributes.isEmpty)48      XCTAssertTrue(subscriptDecl.resultType is SelfType)49      guard case let .codeBlock(codeBlock) = subscriptDecl.body else {50        XCTFail("Failed in getting a code block for subscript declaration.")51        return52      }53      XCTAssertTrue(codeBlock.statements.isEmpty)54    })55  }56  func testModifiers() {57    parseDeclarationAndTest(58      "private nonmutating static final subscript() -> Self {}",59      "private nonmutating static final subscript() -> Self {}",60      testClosure: { decl in61      guard let subscriptDecl = decl as? SubscriptDeclaration else {62        XCTFail("Failed in getting a subscript declaration.")63        return64      }65      XCTAssertTrue(subscriptDecl.attributes.isEmpty)66      XCTAssertEqual(subscriptDecl.modifiers.count, 4)67      XCTAssertEqual(subscriptDecl.modifiers[0], .accessLevel(.private))68      XCTAssertEqual(subscriptDecl.modifiers[1], .mutation(.nonmutating))69      XCTAssertEqual(subscriptDecl.modifiers[2], .static)70      XCTAssertEqual(subscriptDecl.modifiers[3], .final)71      XCTAssertTrue(subscriptDecl.parameterList.isEmpty)72      XCTAssertTrue(subscriptDecl.resultAttributes.isEmpty)73      XCTAssertTrue(subscriptDecl.resultType is SelfType)74      guard case let .codeBlock(codeBlock) = subscriptDecl.body else {75        XCTFail("Failed in getting a code block for subscript declaration.")76        return77      }78      XCTAssertTrue(codeBlock.statements.isEmpty)79    })80  }81  func testAttributeAndModifiers() {82    parseDeclarationAndTest(83      "@a fileprivate subscript() -> Self {}",84      "@a fileprivate subscript() -> Self {}",85      testClosure: { decl in86      guard let subscriptDecl = decl as? SubscriptDeclaration else {87        XCTFail("Failed in getting a subscript declaration.")88        return89      }90      XCTAssertEqual(subscriptDecl.attributes.count, 1)91      XCTAssertEqual(subscriptDecl.attributes[0].name.textDescription, "a")92      XCTAssertEqual(subscriptDecl.modifiers.count, 1)93      XCTAssertEqual(subscriptDecl.modifiers[0], .accessLevel(.fileprivate))94      XCTAssertTrue(subscriptDecl.parameterList.isEmpty)95      XCTAssertTrue(subscriptDecl.resultAttributes.isEmpty)96      XCTAssertTrue(subscriptDecl.resultType is SelfType)97      guard case let .codeBlock(codeBlock) = subscriptDecl.body else {98        XCTFail("Failed in getting a code block for subscript declaration.")99        return100      }101      XCTAssertTrue(codeBlock.statements.isEmpty)102    })103  }104  func testSingleParameter() {105    parseDeclarationAndTest(106      "subscript(i: Int) -> Self {}",107      "subscript(i: Int) -> Self {}",108      testClosure: { decl in109      guard let subscriptDecl = decl as? SubscriptDeclaration else {110        XCTFail("Failed in getting a subscript declaration.")111        return112      }113      XCTAssertTrue(subscriptDecl.attributes.isEmpty)114      XCTAssertTrue(subscriptDecl.modifiers.isEmpty)115      XCTAssertEqual(subscriptDecl.parameterList.count, 1)116      XCTAssertEqual(subscriptDecl.parameterList[0].textDescription, "i: Int")117      XCTAssertTrue(subscriptDecl.resultAttributes.isEmpty)118      XCTAssertTrue(subscriptDecl.resultType is SelfType)119      guard case let .codeBlock(codeBlock) = subscriptDecl.body else {120        XCTFail("Failed in getting a code block for subscript declaration.")121        return122      }123      XCTAssertTrue(codeBlock.statements.isEmpty)124    })125  }126  func testMultipleParameters() {127    parseDeclarationAndTest(128      "subscript(section: Int, row: Int) -> Self {}",129      "subscript(section: Int, row: Int) -> Self {}",130      testClosure: { decl in131      guard let subscriptDecl = decl as? SubscriptDeclaration else {132        XCTFail("Failed in getting a subscript declaration.")133        return134      }135      XCTAssertTrue(subscriptDecl.attributes.isEmpty)136      XCTAssertTrue(subscriptDecl.modifiers.isEmpty)137      XCTAssertEqual(subscriptDecl.parameterList.count, 2)138      XCTAssertEqual(subscriptDecl.parameterList[0].textDescription, "section: Int")139      XCTAssertEqual(subscriptDecl.parameterList[1].textDescription, "row: Int")140      XCTAssertTrue(subscriptDecl.resultAttributes.isEmpty)141      XCTAssertTrue(subscriptDecl.resultType is SelfType)142      guard case let .codeBlock(codeBlock) = subscriptDecl.body else {143        XCTFail("Failed in getting a code block for subscript declaration.")144        return145      }146      XCTAssertTrue(codeBlock.statements.isEmpty)147    })148  }149  func testResultAttributes() {150    parseDeclarationAndTest(151      "subscript() -> @a @b @c Self {}",152      "subscript() -> @a @b @c Self {}",153      testClosure: { decl in154      guard let subscriptDecl = decl as? SubscriptDeclaration else {155        XCTFail("Failed in getting a subscript declaration.")156        return157      }158      XCTAssertTrue(subscriptDecl.attributes.isEmpty)159      XCTAssertTrue(subscriptDecl.modifiers.isEmpty)160      XCTAssertTrue(subscriptDecl.parameterList.isEmpty)161      XCTAssertEqual(subscriptDecl.resultAttributes.count, 3)162      XCTAssertEqual(subscriptDecl.resultAttributes.textDescription, "@a @b @c")163      XCTAssertTrue(subscriptDecl.resultType is SelfType)164      guard case let .codeBlock(codeBlock) = subscriptDecl.body else {165        XCTFail("Failed in getting a code block for subscript declaration.")166        return167      }168      XCTAssertTrue(codeBlock.statements.isEmpty)169    })170  }171  func testGenericParameterClause() {172    parseDeclarationAndTest(173      "subscript<A, B, C>() -> Self {}",174      "subscript<A, B, C>() -> Self {}",175      testClosure: { decl in176      guard let subscriptDecl = decl as? SubscriptDeclaration else {177        XCTFail("Failed in getting a subscript declaration.")178        return179      }180      XCTAssertTrue(subscriptDecl.attributes.isEmpty)181      XCTAssertTrue(subscriptDecl.modifiers.isEmpty)182      XCTAssertEqual(subscriptDecl.genericParameterClause?.textDescription, "<A, B, C>")183      XCTAssertTrue(subscriptDecl.parameterList.isEmpty)184      XCTAssertTrue(subscriptDecl.resultAttributes.isEmpty)185      XCTAssertTrue(subscriptDecl.resultType is SelfType)186      XCTAssertNil(subscriptDecl.genericWhereClause)187      guard case let .codeBlock(codeBlock) = subscriptDecl.body else {188        XCTFail("Failed in getting a code block for subscript declaration.")189        return190      }191      XCTAssertTrue(codeBlock.statements.isEmpty)192    })193  }194  func testGenericWhereClause() {195    parseDeclarationAndTest(196      "subscript<T, S>() -> Self where T == S {}",197      "subscript<T, S>() -> Self where T == S {}",198      testClosure: { decl in199      guard let subscriptDecl = decl as? SubscriptDeclaration else {200        XCTFail("Failed in getting a subscript declaration.")201        return202      }203      XCTAssertTrue(subscriptDecl.attributes.isEmpty)204      XCTAssertTrue(subscriptDecl.modifiers.isEmpty)205      XCTAssertEqual(subscriptDecl.genericParameterClause?.textDescription, "<T, S>")206      XCTAssertTrue(subscriptDecl.parameterList.isEmpty)207      XCTAssertTrue(subscriptDecl.resultAttributes.isEmpty)208      XCTAssertTrue(subscriptDecl.resultType is SelfType)209      XCTAssertEqual(subscriptDecl.genericWhereClause?.textDescription, "where T == S")210      guard case let .codeBlock(codeBlock) = subscriptDecl.body else {211        XCTFail("Failed in getting a code block for subscript declaration.")212        return213      }214      XCTAssertTrue(codeBlock.statements.isEmpty)215    })216  }217  func testCodeBlock() {218    parseDeclarationAndTest(219      "subscript() -> Self { return _weakSelf }",220      "subscript() -> Self {\nreturn _weakSelf\n}",221      testClosure: { decl in222      guard let subscriptDecl = decl as? SubscriptDeclaration else {223        XCTFail("Failed in getting a subscript declaration.")224        return225      }226      XCTAssertTrue(subscriptDecl.attributes.isEmpty)227      XCTAssertTrue(subscriptDecl.modifiers.isEmpty)228      XCTAssertTrue(subscriptDecl.parameterList.isEmpty)229      XCTAssertTrue(subscriptDecl.resultAttributes.isEmpty)230      XCTAssertTrue(subscriptDecl.resultType is SelfType)231      guard case let .codeBlock(codeBlock) = subscriptDecl.body else {232        XCTFail("Failed in getting a code block for subscript declaration.")233        return234      }235      XCTAssertEqual(codeBlock.statements.count, 1)236      XCTAssertEqual(codeBlock.statements[0].textDescription, "return _weakSelf")237    })238  }239  func testGetterSetterBlock() {240    parseDeclarationAndTest(241      "subscript() -> Self { get { return _foo } set { _foo = newValue } }",242      """243      subscript() -> Self {244      get {245      return _foo246      }247      set {248      _foo = newValue249      }250      }251      """,252      testClosure: { decl in253      guard let subscriptDecl = decl as? SubscriptDeclaration else {254        XCTFail("Failed in getting a subscript declaration.")255        return256      }257      XCTAssertTrue(subscriptDecl.attributes.isEmpty)258      XCTAssertTrue(subscriptDecl.modifiers.isEmpty)259      XCTAssertTrue(subscriptDecl.parameterList.isEmpty)260      XCTAssertTrue(subscriptDecl.resultAttributes.isEmpty)261      XCTAssertTrue(subscriptDecl.resultType is SelfType)262      guard case let .getterSetterBlock(getterSetterBlock) = subscriptDecl.body else {263        XCTFail("Failed in getting a getter-setter block for subscript declaration.")264        return265      }266      XCTAssertEqual(getterSetterBlock.getter.textDescription, "get {\nreturn _foo\n}")267      guard let setter = getterSetterBlock.setter else {268        XCTFail("Failed in getting a setter.")269        return270      }271      XCTAssertTrue(setter.attributes.isEmpty)272      XCTAssertNil(setter.mutationModifier)273      XCTAssertNil(setter.name)274      XCTAssertEqual(setter.codeBlock.textDescription, "{\n_foo = newValue\n}")275    })276  }277  func testGetterSetterKeywordBlock() {278    parseDeclarationAndTest(279      "subscript() -> Self { @a @b @c mutating get @x @y @z nonmutating set }",280      """281      subscript() -> Self {282      @a @b @c mutating get283      @x @y @z nonmutating set284      }285      """,286      testClosure: { decl in287      guard let subscriptDecl = decl as? SubscriptDeclaration else {288        XCTFail("Failed in getting a subscript declaration.")289        return290      }291      XCTAssertTrue(subscriptDecl.attributes.isEmpty)292      XCTAssertTrue(subscriptDecl.modifiers.isEmpty)293      XCTAssertTrue(subscriptDecl.parameterList.isEmpty)294      XCTAssertTrue(subscriptDecl.resultAttributes.isEmpty)295      XCTAssertTrue(subscriptDecl.resultType is SelfType)296      guard case let .getterSetterKeywordBlock(getterSetterKeywordBlock) = subscriptDecl.body else {297        XCTFail("Failed in getting a getter-setter-keyword block for subscript declaration.")298        return299      }300      XCTAssertEqual(getterSetterKeywordBlock.getter.attributes.count, 3)301      XCTAssertEqual(getterSetterKeywordBlock.getter.attributes.textDescription, "@a @b @c")...

...19    var operatord : [String : OperatorDeclaration] = [:]20    var precedenceGroup : [String: PrecedenceGroupDeclaration] = [:]21    var protocold : [String: ProtocolDeclaration] = [:]22    var structd : [String : StructDeclaration] = [:]23    var subscriptd : [String : SubscriptDeclaration] = [:]24    var typealiasd : [String : TypealiasDeclaration] = [:]25    var variable : [String : VariableDeclaration] = [:]26}27extension Uml {28    func add(stmt:Statement ,file:String) {29        let m =  Model(stmt: stmt, file: file)30        if let name = m.name() {31            index[name] = m32        }33        34        switch stmt {35        case let declaration as Declaration:36            switch declaration {37            case let decl as ClassDeclaration:38                cls[decl.name.description] = decl39                break40            case let decl as ConstantDeclaration:41                print("constant:",decl)42                break43            case let decl as DeinitializerDeclaration:44                print("deinitializer:",decl)45                break46            case let decl as EnumDeclaration:47                enumd[decl.name.description] = decl48                break49            case let decl as ExtensionDeclaration:50                extensiond[decl.type.description] = decl51                break52            case let decl as FunctionDeclaration:53                function[decl.name.description] = decl54                break55            case let decl as ImportDeclaration:56                importd[decl.path.description] = decl57                break58            case let decl as InitializerDeclaration:59                print("initializer", decl)60                break61            case let decl as OperatorDeclaration:62                print("operator", decl)63                break64            case let decl as PrecedenceGroupDeclaration:65                precedenceGroup[decl.name.description] = decl66                break67            case let decl as ProtocolDeclaration:68                protocold[decl.name.description] = decl69                break70            case let decl as StructDeclaration:71                structd[decl.name.description] = decl72                break73            case let decl as SubscriptDeclaration:74                print("subscript", decl)75                break76            case let decl as TypealiasDeclaration:77                typealiasd[decl.name.description] = decl78                break79            case let decl as VariableDeclaration:80                print("variable", decl)81                break82            default:83                break84            }85        case let expression as Expression:86            switch expression {87            case let exp as BinaryExpression:88                break89            case let exp as PrefixExpression:90                break91            case let exp as PostfixExpression:92                break93            case let exp as PrimaryExpression:94                break95            default:96                break97            }98        default:99            break100        }101    }102    103    func plantUml(cls:ClassDeclaration) -> String {104        let name = cls.name.description105        let clsuml = "class \"\(name)\" as \(name) "106        var body : [String] = []107        for mem in cls.members {108            switch mem {109            case .declaration(let decl):110                switch decl {111                case let dec as VariableDeclaration:112                    body.append(plantUml(variable: dec))113                    break114                case let dec as FunctionDeclaration:115                    body.append(plantUml(dec))116                    break117                default:118                    break119                }120                break121            case .compilerControl(let ccs):122                break123            }124        }125        126        let bodys = body.joined(separator: "\n")127        var res = clsuml + "{\n" + bodys + "\n}"128        return res129    }130    131    func plantUml(variable:VariableDeclaration) -> String {132        switch variable.body {133        case .codeBlock(_, <#T##TypeAnnotation#>, <#T##CodeBlock#>):134            <#code#>135        default:136            <#code#>137        }138        return variable.body.description139    }140    141    func plantUml(_ fun:FunctionDeclaration) -> String {142        return "\(fun.name)()"143    }144}145extension Uml {146    static let share = Uml()147    148    class Model {149        var stmt : Statement150        var file : String151        152        init(stmt : Statement, file : String) {153            self.stmt = stmt154            self.file = file155        }156        157        func name() -> String? {158            var res : String? = nil159            switch stmt {160            case let declaration as Declaration:161                switch declaration {162                case let decl as ClassDeclaration:163                    res = name(id: decl.name)164                case let decl as ConstantDeclaration:165                    //                    res = name(id: decl.name)166                    break167                case let decl as DeinitializerDeclaration:168                    //                    res = name(id: decl.name)169                    break170                case let decl as EnumDeclaration:171                    res = name(id: decl.name)172                case let decl as ExtensionDeclaration:173                    //                    res = name(id: decl.name)174                    break175                case let decl as FunctionDeclaration:176                    res = name(id: decl.name)177                case let decl as ImportDeclaration:178                    //                    res = name(id: decl.name)179                    break180                case let decl as InitializerDeclaration:181                    //                    res = name(id: decl.name)182                    break183                case let decl as OperatorDeclaration:184                    //                    res = name(id: decl.name)185                    break186                case let decl as PrecedenceGroupDeclaration:187                    res = name(id: decl.name)188                case let decl as ProtocolDeclaration:189                    res = name(id: decl.name)190                case let decl as StructDeclaration:191                    res = name(id: decl.name)192                case let decl as SubscriptDeclaration:193                    //                    res = name(id: decl.name)194                    break195                case let decl as TypealiasDeclaration:196                    res = name(id: decl.name)197                case let decl as VariableDeclaration:198                    //                    res = name(id: decl.name)199                    break200                default:201                    break202                }203            default:204                break205            }206            return res...

1import SwiftGrammar2struct ScannedDeclarationContexts {3    // var ([a-z]+?)([A-Z][a-z]*?)s: \[([a-zA-Z_.]*?)\] = \[\]4    // } else if let $1$2 = declaration.$1_\l$2() {\n    scannedContext.$1$2s.append($1$2)\n5    6    var importDeclarations: [SwiftParser.Import_declarationContext] = []7    var constantDeclarations: [SwiftParser.Constant_declarationContext] = []8    var variableDeclarations: [SwiftParser.Variable_declarationContext] = []9    var typealiasDeclarations: [SwiftParser.Typealias_declarationContext] = []10    var functionDeclarations: [SwiftParser.Function_declarationContext] = []11    var enumDeclarations: [SwiftParser.Enum_declarationContext] = []12    var structDeclarations: [SwiftParser.Struct_declarationContext] = []13    var classDeclarations: [SwiftParser.Class_declarationContext] = []14    var protocolDeclarations: [SwiftParser.Protocol_declarationContext] = []15    var initializerDeclarations: [SwiftParser.Initializer_declarationContext] = []16    var deinitializerDeclarations: [SwiftParser.Deinitializer_declarationContext] = []17    var extensionDeclarations: [SwiftParser.Extension_declarationContext] = []18    var subscriptDeclarations: [SwiftParser.Subscript_declarationContext] = []19    var operatorDeclarations: [SwiftParser.Operator_declarationContext] = []20}21final class DeclarationContextsScanner {22    func scan(context: SwiftParser.DeclarationsContext) -> ScannedDeclarationContexts {23        return scan(context.declaration())24    }25    26    func scan(declarationContexts: [SwiftParser.DeclarationContext]) -> ScannedDeclarationContexts {27        var scannedContext = ScannedDeclarationContexts()28        29        for declaration in declarationContexts {30            guard let child = declaration.children?.first else {31                continue32            }33            34            if let importDeclaration = child as? SwiftParser.Import_declarationContext {35                scannedContext.importDeclarations.append(importDeclaration)36                37            } else if let constantDeclaration = child as? SwiftParser.Constant_declarationContext {38                scannedContext.constantDeclarations.append(constantDeclaration)39                40            } else if let variableDeclaration = child as? SwiftParser.Variable_declarationContext {41                scannedContext.variableDeclarations.append(variableDeclaration)42                43            } else if let typealiasDeclaration = child as? SwiftParser.Typealias_declarationContext {44                scannedContext.typealiasDeclarations.append(typealiasDeclaration)45                46            } else if let functionDeclaration = child as? SwiftParser.Function_declarationContext {47                scannedContext.functionDeclarations.append(functionDeclaration)48                49            } else if let enumDeclaration = child as? SwiftParser.Enum_declarationContext {50                scannedContext.enumDeclarations.append(enumDeclaration)51                52            } else if let structDeclaration = child as? SwiftParser.Struct_declarationContext {53                scannedContext.structDeclarations.append(structDeclaration)54                55            } else if let classDeclaration = child as? SwiftParser.Class_declarationContext {56                scannedContext.classDeclarations.append(classDeclaration)57                58            } else if let protocolDeclaration = child as? SwiftParser.Protocol_declarationContext {59                scannedContext.protocolDeclarations.append(protocolDeclaration)60                61            } else if let initializerDeclaration = child as? SwiftParser.Initializer_declarationContext {62                scannedContext.initializerDeclarations.append(initializerDeclaration)63                64            } else if let deinitializerDeclaration = child as? SwiftParser.Deinitializer_declarationContext {65                scannedContext.deinitializerDeclarations.append(deinitializerDeclaration)66                67            } else if let extensionDeclaration = child as? SwiftParser.Extension_declarationContext {68                scannedContext.extensionDeclarations.append(extensionDeclaration)69                70            } else if let subscriptDeclaration = child as? SwiftParser.Subscript_declarationContext {71                scannedContext.subscriptDeclarations.append(subscriptDeclaration)72                73            } else if let operatorDeclaration = child as? SwiftParser.Operator_declarationContext {74                scannedContext.operatorDeclarations.append(operatorDeclaration)75            }76        }77        78        return scannedContext79    }80}...

1import Foundation2public class Class1 {3    public func method1() -> Int {4    }5}6import Foundation7public class Class2 {8    public func method2() -> Int {9    }10}11import Foundation12public class Class3 {13    public func method3() -> Int {14    }15}16import Foundation17public class Class4 {18    public func method4() -> Int {19    }20}21import Foundation22public class Class5 {23    public func method5() -> Int {24    }25}26import Foundation27public class Class6 {28    public func method6() -> Int {29    }30}31import Foundation32public class Class7 {33    public func method7() -> Int {34    }35}36import Foundation37public class Class8 {38    public func method8() -> Int {39    }40}41import Foundation42public class Class9 {43    public func method9() -> Int {44    }45}46import Foundation47public class Class10 {48    public func method10() -> Int {49    }50}51import Foundation52public class Class11 {53    public func method11() -> Int {54    }55}56import Foundation

1import Mockingbird2import XCTest3@testable import MockingbirdTestsHost4class SubscriptTests: XCTestCase {5    var mock = MockSubscriptDeclaration()6    override func setUp() {7        super.setUp()8        mock = MockSubscriptDeclaration()9    }10    func testSubscript() {11        mock.stub { mock in12            when(mock[1]).thenReturn("1")13        }14        XCTAssertEqual(mock[1], "1")15    }16}17import Mockingbird18import XCTest19@testable import MockingbirdTestsHost20class SubscriptTests: XCTestCase {21    var mock = MockSubscriptDeclaration()22    override func setUp() {23        super.setUp()24        mock = MockSubscriptDeclaration()25    }26    func testSubscript() {27        mock.stub { mock in28            when(mock[1]).thenReturn("1")29        }30        XCTAssertEqual(mock[1], "1")31    }32}33import Mockingbird34import XCTest35@testable import MockingbirdTestsHost36class SubscriptTests: XCTestCase {37    var mock = MockSubscriptDeclaration()38    override func setUp() {39        super.setUp()40        mock = MockSubscriptDeclaration()41    }42    func testSubscript() {43        mock.stub { mock in44            when(mock[1]).thenReturn("1")45        }46        XCTAssertEqual(mock[1], "1")47    }48}49import Mockingbird50import XCTest51@testable import MockingbirdTestsHost52class SubscriptTests: XCTestCase {53    var mock = MockSubscriptDeclaration()54    override func setUp() {55        super.setUp()56        mock = MockSubscriptDeclaration()57    }58    func testSubscript() {59        mock.stub { mock in60            when(mock[1]).thenReturn("1")61        }62        XCTAssertEqual(mock[1], "1")63    }64}65import Mockingbird66import XCTest67@testable import MockingbirdTestsHost68class SubscriptTests: XCTestCase {69    var mock = MockSubscriptDeclaration()70    override func setUp() {71        super.setUp()72        mock = MockSubscriptDeclaration()73    }74    func testSubscript() {75        mock.stub { mock in76            when(mock[1]).thenReturn("1")77        }78        XCTAssertEqual(mock[1], "1")79    }80}

1import Mockingbird2import XCTest3class SubscriptDeclarationTests: XCTestCase {4    func testSubscriptDeclaration() {5        let sub = SubscriptDeclaration(name: "subscript", type: "Int", parameters: [Parameter(name: "index", type: "Int")], attributes: [.mutating, .convenience])6        XCTAssertEqual(sub.name, "subscript")7        XCTAssertEqual(sub.type, "Int")8        XCTAssertEqual(sub.parameters.count, 1)9        XCTAssertEqual(sub.parameters[0].name, "index")10        XCTAssertEqual(sub.parameters[0].type, "Int")11        XCTAssertEqual(sub.attributes.count, 2)12        XCTAssertTrue(sub.attributes.contains(.mutating))13        XCTAssertTrue(sub.attributes.contains(.convenience))14    }15}16import Mockingbird17import XCTest18class ClassDeclarationTests: XCTestCase {19    func testClassDeclaration() {20        let classDecl = ClassDeclaration(name: "ClassDeclaration", accessLevel: .internal, attributes: [.final])21        XCTAssertEqual(classDecl.name, "ClassDeclaration")22        XCTAssertEqual(classDecl.accessLevel, .internal)23        XCTAssertEqual(classDecl.attributes.count, 1)24        XCTAssertTrue(classDecl.attributes.contains(.final))25    }26}27import Mockingbird28import XCTest29class ProtocolDeclarationTests: XCTestCase {30    func testProtocolDeclaration() {31        let protocolDecl = ProtocolDeclaration(name: "ProtocolDeclaration", accessLevel: .internal, attributes: [.final])32        XCTAssertEqual(protocolDecl.name, "ProtocolDeclaration")33        XCTAssertEqual(protocolDecl.accessLevel, .internal)34        XCTAssertEqual(protocolDecl.attributes.count, 1)35        XCTAssertTrue(protocolDecl.attributes.contains(.final))36    }37}38import Mockingbird39import XCTest40class PropertyDeclarationTests: XCTestCase {41    func testPropertyDeclaration() {42        let property = PropertyDeclaration(name: "property", type: "Int", accessLevel: .internal, isStatic: true, attributes: [.final])43        XCTAssertEqual(property.name, "property")44        XCTAssertEqual(property.type, "Int")45        XCTAssertEqual(property.accessLevel, .internal)46        XCTAssertTrue(property.isStatic)47        XCTAssertEqual(property.attributes.count, 1)48        XCTAssertTrue(property.attributes.contains(.final))49    }50}

1import Foundation2import Mockingbird3import MockingbirdFramework4struct SubscriptDeclaration {5    init(name: String, parameters: [Parameter], returnType: Type, attributes: [Attribute], modifiers: [Modifier], accessLevel: AccessLevel) {6    }7}8import Foundation9import Mockingbird10import MockingbirdFramework11struct SubscriptDeclaration {12    init(name: String, parameters: [Parameter], returnType: Type, attributes: [Attribute], modifiers: [Modifier], accessLevel: AccessLevel) {13    }14}15import Foundation16import Mockingbird17import MockingbirdFramework18struct SubscriptDeclaration {19    init(name: String, parameters: [Parameter], returnType: Type, attributes: [Attribute], modifiers: [Modifier], accessLevel: AccessLevel) {20    }21}22import Foundation23import Mockingbird24import MockingbirdFramework25struct SubscriptDeclaration {

1import Mockingbird2class SubscriptDeclarationTest {3  func testSubscriptDeclaration() {4    let subscriptDeclaration = SubscriptDeclaration()5    print(subscriptDeclaration)6  }7}8import MockingbirdFramework9class SubscriptDeclarationTest {10  func testSubscriptDeclaration() {11    let subscriptDeclaration = SubscriptDeclaration()12    print(subscriptDeclaration)13  }14}15import MockingbirdFramework16class SubscriptDeclarationTest {17  func testSubscriptDeclaration() {18    let subscriptDeclaration = SubscriptDeclaration()19    print(subscriptDeclaration)20  }21}22import MockingbirdFramework23class SubscriptDeclarationTest {24  func testSubscriptDeclaration() {25    let subscriptDeclaration = SubscriptDeclaration()26    print(subscriptDeclaration)27  }28}29import MockingbirdFramework30class SubscriptDeclarationTest {

1let sub = SubscriptDeclaration(name: "subscript", parameterClause: "(_ index: Int)", returnType: "String", attributes: [], modifiers: [])2let sub2 = SubscriptDeclaration(name: "subscript", parameterClause: "(_ index: Int)", returnType: "String", attributes: [], modifiers: [])3let sub3 = SubscriptDeclaration(name: "subscript", parameterClause: "(_ index: Int)", returnType: "String", attributes: [], modifiers: [])4let sub4 = SubscriptDeclaration(name: "subscript", parameterClause: "(_ index: Int)", returnType: "String", attributes: [], modifiers: [])5let sub5 = SubscriptDeclaration(name: "subscript", parameterClause: "(_ index: Int)", returnType: "String", attributes: [], modifiers: [])6let sub6 = SubscriptDeclaration(name: "subscript", parameterClause: "(_ index: Int)", returnType: "String", attributes: [], modifiers: [])7let sub7 = SubscriptDeclaration(name: "subscript", parameterClause: "(_ index: Int)", returnType: "String", attributes: [], modifiers: [])8let sub8 = SubscriptDeclaration(name: "subscript", parameterClause: "(_ index: Int)", returnType: "String", attributes: [], modifiers: [])9let sub9 = SubscriptDeclaration(name: "subscript", parameterClause: "(_ index: Int)", returnType: "String", attributes: [], modifiers: [])10let sub10 = SubscriptDeclaration(name: "subscript", parameterClause: "(_ index: Int)", returnType: "String", attributes: [], modifiers: [])11let sub11 = SubscriptDeclaration(name: "subscript", parameterClause: "(_ index: Int)", returnType: "String", attributes: [], modifiers: [])12let sub12 = SubscriptDeclaration(name: "subscript", parameterClause: "(_ index: Int)", returnType: "String", attributes: [], modifiers: [])13let sub13 = SubscriptDeclaration(name: "subscript", parameterClause: "(_ index: Int)", returnType: "String", attributes: [], modifiers: [])14let sub14 = SubscriptDeclaration(name: "subscript", parameterClause: "(_ index: Int)", returnType: "String", attributes: [], modifiers: [])15let sub15 = SubscriptDeclaration(name: "subscript", parameterClause: "(_ index: Int)", returnType: "String", attributes: [], modifiers: [])

1let source = try! SourceFile(path: "1.swift")2let decl = try! SubscriptDeclaration(source: source, offset: 0)3print(decl.parameters)4let source = try! SourceFile(path: "2.swift")5let decl = try! SubscriptDeclaration(source: source, offset: 0)6print(decl.parameters)