 
         context("when that stuff is brown") {
             beforeEach {
-
-            }
-
-            beforeEach {
-                print("before each")
+                timingLogs.append("before each")
             }
 
             afterEach {
-                print("after each\n")
+                timingLogs.append("after each")
             }
 
             it("should 1") {
-                print("should 1")
-                expect(true).to(beTrue())
-            }
-
-            group("abc") {
+                expect(Block { timingLogs.append("should 1") }).to(log())
+            }
+
+            group {
                 it("should 2") {
-                    print("should 2")
-                    expect(true).to(beTrue())
+                    expect(Block { timingLogs.append("should 2") }).to(log())
                 }
 
                 it("should 3") {
-                    print("should 3")
-                    expect(true).to(beTrue())
+                    expect(Block { timingLogs.append("should 3") }).to(log())
                 }
                 
                 it("should 4") {
-                    print("should 4")
-                    expect(true).to(beTrue())
+                    expect(Block { timingLogs.append("should 4") }).to(log())
                 }
             }
         }

    func add(_ scope: Scope)
    func add(_ step: Step)
    func add(_ it: It)
    func add(_ expect: Expect)
}

private enum StepType {

    }
}

protocol BlockType {}
struct Block: BlockType {
    let held: () -> Void

    init(_ held: @escaping () -> Void) {
        self.held = held
    }
}
class LogTrackerMatcher<T: BlockType>: Matcher<T> {
    override func execute(actual: T) -> Bool {
        (actual as! Block).held()
        return true
    }
}

// - Global Matcher Functions

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

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

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

func log<T: BlockType>() -> Matcher<T> {
    return LogTrackerMatcher()
}


