         return prePrefix + Constant.OutPutPrefix.it + (title.isEmpty ? Constant.emptyTitle : title)
     }
 
-    init(title: String, closure: @escaping () -> Bool, mark: Mark) {
+    init(title: String, mark: Mark) {
         self.title = title
-        self.closure = closure
         self.mark = mark
     }
 
     func process(underFocus: Bool, underPending: Bool) {
         self.underFocus = underFocus
         self.underPending = underPending
+    }
+
+    // MARK: TrackedScope Protocol
+
+    func add(_ scope: Scope) {
+        fatalError(I18n.t(.notAllowedInIt("\(scope.type)")))
+    }
+
+    func add(_ step: Step) {
+        fatalError(I18n.t(.notAllowedInIt("\(step.type)")))
+    }
+
+    func add(_ it: It) {
+        fatalError(I18n.t(.notAllowedInIt("it")))
+    }
+
+    func add(_ expect: Expect) {
+        expects.append(expect)
     }
 
     // MARK: Helper

}

private class Scope: TrackedScope {
    private let type: ScopeType
    private let title: String
    private let mark: Mark

    private var underFocus: Bool = false
    private var underPending: Bool = false


// Matcher Framework

class Matcher<T> {
    func execute(actual: T) -> Bool {
        fatalError("This is a Base class. Must subclass to use")
    }
}

// - Default Matchers

class EqualMatcher<T: Equatable>: Matcher<T> {
    let expected: T

    init(expected: T) {
        self.expected = expected
    }

    override func execute(actual: T) -> Bool {
        return actual == expected
    }
}

protocol BoolType {}
extension Bool: BoolType {}

class BeTrueMatcher<T: BoolType>: Matcher<T> {
    override func execute(actual: T) -> Bool {
        return (actual as! Bool)
    }
}

class BeFalseMatcher<T: BoolType>: Matcher<T> {
    override func execute(actual: T) -> Bool {
        return !(actual as! Bool)
    }
}

// - Global Matcher Functions

func equal<T: Equatable>(_ expected: T) -> Matcher<T> {
    return EqualMatcher(expected: expected)
}

func beTrue<T: BoolType>() -> Matcher<T> {
    return BeTrueMatcher()
}

func beFalse<T: BoolType>() -> Matcher<T> {
    return BeFalseMatcher()
}


// BDD Framework

private struct Constant {
    static let levelSpace = "   "
