quick / quick

The Swift (and Objective-C) testing framework.

Quick is a behavior-driven development framework for Swift and Objective-C. Inspired by RSpec, Specta, and Ginkgo.

// Swift

import Quick
import Nimble

class TableOfContentsSpec: QuickSpec {
  override class func spec() {
    describe("the 'Documentation' directory") {
      it("has everything you need to get started") {
        let sections = Directory("Documentation").sections
        expect(sections).to(contain("Organized Tests with Quick Examples and Example Groups"))
        expect(sections).to(contain("Installing Quick"))
      }

      context("if it doesn't have what you're looking for") {
        it("needs to be updated") {
          let you = You(awesome: true)
          expect{you.submittedAnIssue}.toEventually(beTruthy())
        }
      }
    }
  }
}

Nimble

Quick comes together with Nimble — a matcher framework for your tests. You can learn why XCTAssert() statements make your expectations unclear and how to fix that using Nimble assertions here.

Swift Version

Certain versions of Quick and Nimble only support certain versions of Swift. Depending on which version of Swift your project uses, you should use specific versions of Quick and Nimble. Use the table below to determine which versions of Quick and Nimble are compatible with your project.

Swift version	Quick version	Nimble version
Swift 5.2	v3.0.0 or later	v9.0.0 or later
Swift 4.2 / Swift 5	v1.3.2 or later	v7.3.2 or later
Swift 3 / Swift 4	v1.0.0 or later	v5.0.0 or later
Swift 2.2 / Swift 2.3	v0.9.3	v4.1.0

Documentation

All documentation can be found in the Documentation folder, including detailed installation instructions for CocoaPods, Carthage, Git submodules, Swift Package Manager, and more. For example, you can install Quick and Nimble using CocoaPods by adding the following to your Podfile:

# Podfile

use_frameworks!

target "MyApp" do
  # Normal libraries

  target 'MyApp_Tests' do
    inherit! :search_paths

    pod 'Quick'
    pod 'Nimble'
  end
end

You can also install Quick and Nimble using Swift Package Manager by adding the following to the dependencies section your Package.swift:

dependencies: [
    .package(url: "https://github.com/Quick/Quick.git", from: "7.0.0"),
    .package(url: "https://github.com/Quick/Nimble.git", from: "12.0.0"),
],

Projects using Quick

Over ten-thousand apps use either Quick and Nimble however, as they are not included in the app binary, neither appear in “Top Used Libraries” blog posts. Therefore, it would be greatly appreciated to remind contributors that their efforts are valued by compiling a list of organizations and projects that use them.

Does your organization or project use Quick and Nimble? If yes, please add your project to the list.

Who uses Quick

Similar to projects using Quick, it would be nice to hear why people use Quick and Nimble. Are there features you love? Are there features that are just okay? Are there some features we have that no one uses?

Have something positive to say about Quick (or Nimble)? If yes, provide a testimonial here.

Privacy Statement

Quick is a library that is only used for testing and should never be included in the binary submitted to App Store Connect. Your app will be rejected if you do include Quick in the submitted binary because Quick uses private APIs to better integrate with Xcode.

Despite not being shipped to Apple, Quick does not and will never collect any kind of analytics or tracking.

License

Apache 2.0 license. See the LICENSE file for details.

quick's Issues

Pending examples

Users should be able to mark an example "pending". A pending example will not be executed. If possible, a pending example should display a warning in Xcode, in order to remind the user to come back and fix the test later.

it("fails") {
    expect([1, 2]).to.contain(3) // This line is highlighted red in Xcode
}

pending("does not fail, but displays a warning") {
    expect([5, 6]).to.contain(7) // This line is highlighted yellow
}

Users should also be able to mark entire example groups as pending. Pending example groups will not be run.

pending("this whole group is pending") { // This line is highlighted yellow
    it("does not fail, because it's never run") {
        expect(false).to.beTrue() // This line is *not* highlighted red
    }
}

[Nimble] Fatal exception if expect is not within it() closure

If an expect is placed outside of an it() closure, you get a nasty, horrible, fatal stop that is not very easy to understand.

context("something") {

    expect(false).to.beTrue()

}

2014-06-10 13:17:12.118 xctest[35550:303] *** Assertion failure in void _XCTFailureHandler(XCTestCase *, BOOL, const char *, NSUInteger, NSString *, NSString *, ...)(), /SourceCache/XCTest/XCTest-59.5/XCTestFramework/OtherSources/XCTestAssertionsImpl.m:43
2014-06-10 13:17:12.119 xctest[35550:303] *** Terminating app due to uncaught exception 'NSInternalInconsistencyException', reason: 'Parameter "test" must not be nil.'
*** First throw call stack:
(
    0   CoreFoundation                      0x00007fff8b9c125c __exceptionPreprocess + 172
    1   libobjc.A.dylib                     0x00007fff9209fe75 objc_exception_throw + 43
    2   CoreFoundation                      0x00007fff8b9c1038 +[NSException raise:format:arguments:] + 104
    3   Foundation                          0x00007fff8cfc0e06 -[NSAssertionHandler handleFailureInFunction:file:lineNumber:description:] + 169
    4   XCTest                              0x00000001004cb239 _XCTFailureHandler + 241
    5   XCTest                              0x00000001004cb664 _XCTPreformattedFailureHandler + 81
    6   libswiftXCTest.dylib                0x000000010519a33c _TF6XCTest7XCTFailFTSS4fileSS4lineSi_T_ + 1804
    7   Quick                               0x00000001050ac375 _TFC5Quick11Expectation8evaluatefS0_FCS_7MatcherT_ + 1877
    8   Quick                               0x00000001050af4fc _TFC5Quick10Prediction6beTruefS0_FT_T_ + 76
    9   QuickTests                          0x00000001004935a6 _TFFC10QuickTests12OptionalSpec13exampleGroupsFMS0_FT_T_U1_FT_T_ + 310
    10  Quick                               0x00000001050b7fe4 _TF5Quick8describeFTSSFT_T__T_ + 372
    11  Quick                               0x00000001050b80ca _TF5Quick7contextFTSSFT_T__T_ + 74
    12  QuickTests                          0x00000001004922a3 _TFC10QuickTests12OptionalSpec13exampleGroupsfMS0_FT_T_ + 595
    13  QuickTests                          0x0000000100492439 _TToFC10QuickTests12OptionalSpec13exampleGroupsfMS0_FT_T_ + 25
    14  Quick                               0x00000001050bb250 +[QuickSpec initialize] + 144
    15  libobjc.A.dylib                     0x00007fff92098371 _class_initialize + 645
    16  libobjc.A.dylib                     0x00007fff920a4254 lookUpImpOrForward + 170
    17  libobjc.A.dylib                     0x00007fff92097169 objc_msgSend + 233
    18  CoreFoundation                      0x00007fff8b8f3e9d -[__NSSetM member:] + 77
    19  CoreFoundation                      0x00007fff8b8dd008 -[NSSet containsObject:] + 24
    20  XCTest                              0x00000001004cfb6a +[XCTestCase(RuntimeUtilities) allSubclasses] + 159
    21  XCTest                              0x00000001004c5110 +[XCTestSuite _suiteForBundleCache] + 183
    22  XCTest                              0x00000001004c52eb +[XCTestSuite suiteForBundleCache] + 34
    23  XCTest                              0x00000001004c567e +[XCTestSuite allTests] + 56
    24  XCTest                              0x00000001004d0c3f __33+[XCTestProbe specifiedTestSuite]_block_invoke + 153
    25  libdispatch.dylib                   0x00007fff907b228d _dispatch_client_callout + 8
    26  libdispatch.dylib                   0x00007fff907b21fc dispatch_once_f + 79
    27  XCTest                              0x00000001004d0ba4 +[XCTestProbe specifiedTestSuite] + 98
    28  XCTest                              0x00000001004d0ea3 +[XCTestProbe runTests:] + 105
    29  xctest                              0x00000001000012d6 xctest + 4822
    30  xctest                              0x0000000100001632 xctest + 5682
    31  xctest                              0x0000000100000f53 xctest + 3923
    32  libdyld.dylib                       0x00007fff8c1a15fd start + 1
)
libc++abi.dylib: terminating with uncaught exception of type NSException

Continuous integration (or at least a target/script that runs all tests)

Travis CI almost certainly doesn't run beta versions of Xcode. I wonder if it's possible to run an Xcode bots server on my machine and serve the CI page publicly?

[Nimble] Add undocumented matchers to README

Ain't nobody gonna use 'em if they don't know 'bout 'em.

• beLessThanOrEqualTo
• beLessThan
• beGreaterThan
• beGreaterThanOrEqualTo
• beEmpty

[Nimble] Custom matchers

Users should be able to define custom matchers. In fact, I'm pretty sure they already can, by extending the Prediction class, just like all the built-in matchers. Still,

• the process should be simplified as much as possible, and
• it should be documented in the README

Crash when running a subset of the test suite

Running any of the specs individually (via the test navigator) causes a crash here: https://github.com/modocache/Quick/blob/master/QuickTests/Quick/QuickSpec.swift#L41. It's an array out of bounds exception, presumably related to the fact that this getter has global side-effects and maybe makes assumptions about the number of examples that will exist at runtime.

fatal error: Array index out of range

[Nimble] Overload contain() matcher to accept variadic parameter

It would be nice to be able do this:

let numbers = [4, 8, 15, 16, 23, 42]

expect(numbers).to.contain(8, 23, 16) // passes
expect(numbers).toNot.contain(42) // fails

[Nimble] Use of C primitive types in expectations

it("primitive types") {
    var a: CInt = 1
    expect(a).to.equal(1)
}

The expect line gives the error "could not find member 'to'", probably because C primitive types are not objects in the Swift conventional sense.

You can wrap this in

expect(Int(a)).to.equal(1)

to get around it. Might be nice if the expect() call can be overloaded to do this for you.

Add unit tests

Right now Quick is mainly tested via functional tests. Add a more comprehensive unit test suite, using XCTestCase, for the classes and functions in Core.

Linking to Quick.framework from iOS test target fails

When writing tests against an iOS target it complains with saying that the header cocoa.h fails.

Will do further investigation to see how this can be updated.

Add specify{}

Kiwi’s specify() was incredibly useful for simple examples where the expectation could provide the description.

Kiwi example:

specify(^{
        [[sut should] beKindOfClass:[UIDocument class]];
});

[Nimble] Support expectations in Objective-C

NOTE: This issue used to track Objective-C compatibility for both Quick and Nimble.

Users should be able to write their tests in Objective-C:

@interface AppDelegateSpec : QuickSpec; @end

@implementation AppDelegateSpec

+ (void)exampleGroups {
    describe("AppDelegate", ^{
        __block AppDelegate *appDelegate = nil;
        beforeEach(^{
            appDelegate = [AppDelegate new];
        })

        it("terminates the application when the last window is closed", ^{
            [expect([appDelegate applicationShouldTerminateAfterLastWindowClosed:nil]).to beTrue];
        });
    });
}

@end

Object instantiated as a different class on Spec

When initializing one of my controllers in a spec, I get the following class _TtC9OiOrlando14NewsController for an object that should be of type NewsController.

The following code works on a regular build, but crashes on the tests due to the incorrect typecasting:

    let storyboard = UIStoryboard(name: "Main", bundle: nil)
    let controller: NewsController = storyboard.instantiateViewControllerWithIdentifier("NewsController") as NewsController;

If I don't typecast to NewsController, but to UIViewController, it doesn't crash:

    let storyboard = UIStoryboard(name: "Main", bundle: nil)
    let controller: UIViewController = storyboard.instantiateViewControllerWithIdentifier("NewsController") as UIViewController;

This first test succeeds, and the second fails:

describe("the news controller after initialized") {
    it("is should be of type UIViewController") {
        expect(controller.isKindOfClass(UIViewController)).to.beTrue()
    }
}

describe("the news controller after initialized") {
   it("is should be of type NewsController") {
      expect(controller.isKindOfClass(NewsController)).to.beTrue()
    }
}

The NewsController class is correctly included in the Tests target.

Am I doing something wrong?
Are the objects being wrapped in a different object at runtime?

Expose nmb_expect to Objective-C breaks nimble

Thanks for making this!

I had time to try it out today but I'm unable to compile the library (even when just cloning master) due to changes made in modocache@712a3e5#diff-e4f6f6b9c7424260c6bb6b195e90b7ed

Specifically, these imports in Nimble.h are not valid:

#import <Nimble/NMBDSL.h>
#import <Nimble/NMBDSL+BeNil.h>
#import <Nimble/NMBDSL+BeTrue.h>
#import <Nimble/NMBDSL+BeFalse.h>

Simply removing them allows the project (Nimble) to compile again. I would make a pull request but it seems like either you are not quite finished with this work yet and/or you forgot to commit some related changes.

In any case, I thought I would let you know that master is broken.

BeNil matcher

Matches on subjects that are nil. Does not match on any non-nil objects.

expect(nil).to.beNil()
expect("Daenerys Targaryen").notTo.beNil()

[Quick] Shared examples

Add shared examples to Quick.

Luckily, some nerd wrote about what shared examples are and why they're used, as well as about how they're implemented in RSpec. That same dork implemented them in Kiwi: kiwi-bdd/Kiwi#442

Specta also includes shared examples, so their implementation can also be used as a guide.

Adding shared examples might help with issue #37 as well.

[Nimble] Support for @lazy property

Thx for you hard work.

Nimble seems that can not expect @lazy property.

I have a @lazy property:

@lazy var appIndexModel: QGLAppIndexModel = {
    let JSONFileURL = self.bundleBaseURL.URLByAppendingPathComponent(self.appIndexJSONFileName)
    var model = QGLAppIndexModel(JSONFileURL: JSONFileURL)
    return model
  }()

Nimble seems can not expect it.

CodeSign issue for Framework in iOS 8.0

I get this error everytime I try to run my tests:
CodeSign error: code signing is required for product type 'Framework' in SDK 'iOS 8.0'

I followed the guide in the README to get started, is there something I may have missed?

README screenshot needs to be updated

The updated screenshot should use spec() instead of exampleGroups(). It should also display the updated fail message: failed - expected 'Click click click!', got 'Click!'. I think it should also use 4 space tabs since (1.) that‘s the standard in the project guidelines and (2.) that’s the Xcode default.

Here is the stab I took at it. I also made the decision to format the nested descriptions for sentence output. I.e., The initial describe is capitalized. The its end in periods.

Add specs for matchers

Right now only the Contain matcher has a corresponding spec. Add specs for BeTrue, Equal, and any other matchers that do not have specs.

[Nimble] Failure reporting using Expected: Got:

Failure messages currently treat the actual and expected values in an expectation as interchangeable. This shouldn’t be. An expectation tests an actual value against an expected value. For example, let actualValue = 2; expect(actualValue).to.equal(5) reports expected '2' to be equal to '5'. That expression would be equivalent to expected '5' to be equal to '2'. But the expectation (and certainly the spec’s author) doesn’t just expect that two values be equal, it expects that the actual value should equal the expected value of 5. RSpec reports this as expected: 5, got: 2. RSpec’s reporting clarifies the intention of the expectation and the meaning of its failure. Expected '5', got '2' would do.

Support custom output formatters

Luckily, some nerd wrote down how RSpec implements custom output formatters.

An example in Objective-C can be found here: kiwi-bdd/Kiwi#449

I wonder if it'd be possible to implement an output formatter that aggregates results and displays an OS X notification with a breakdown of passed, pending, failed, and errored?

Podspec and distribution via CocoaPods

As of afc541e, Quick can be manually installed in any XCTest bundle. It would be nice to integrate with CocoaPods to automate this process.

I'm not sure if this is currently possible; see my comment here for details on the issue. Basically, CocoaPods packages Swift files up and places them in a Pods project, but it does not define a Swift module (as far as I can tell).

CocoaPods/CocoaPods#2222 appears to add .swift files to the list of files that CocoaPods packages by default, but that probably won't solve the module problem. Might be worth asking at CocoaPods/CocoaPods#2218.

Xcode test navigator integration

Currently tests do not appear correctly in Xcode's test navigator.

[Quick] QuickSpec Xcode template

Add a simple template that takes the name of the spec and produces:

import Quick

class {{ name of spec }}: QuickSpec {
    override class func exampleGroups() {

    }
}

Note that the spec should not include any header comments; users may put those in themselves.

A simple install script would be nice. Jumping through whatever hoops are necessary to register it with Alcatraz should also be taken.

beforeSuite/afterSuite

Should behave like Ginkgo's BeforeSuite/AfterSuite.

[Nimble] The generic matcher should support `Any?` expected parameter

Matchers such as beKindOfClass() and beMemberOfClass() cannot be written since the expected: init parameter is of type NSObject? and not Any?. Types (i.e., Type, ExistentialMetatype, and anything conforming to AnyClass) cannot be cast as NSObject, though Types and inheritors of NSObject can both be cast as Any?.

Integrate the Rewritten Nimble

See the new nimble. This is mostly a note to myself which issues are related to this one.

The new Nimble addresses the following open issues:

• #84 Custom Matchers (v0.1.0 beta)
• #82 Test for expectations (v0.1.0 beta)
• #70 Support for @lazy property (v0.1.0 beta) -- Needs a test to ensure no regressions.
• #75 Closure and aynchronous expectation tests -- probably still better to add more tests. (v0.1.0 beta)
• #88 Dictionary support to beEmpty() matcher
• #87 Nimble is terrible
• #86 The generic matcher should support Any? expected parameter
• #66 Prettier Objective-C Syntax (at least the Nimble part of it)
• #61 Overload contain() matcher to accept variadic parameters
• Would close PR #31 WIP for using Generics to allow for more flexible type matching
• Would close PR #23 Test subject is Any, but introduces Swift compiler fatal crash
• #17 Use of C primitive types in expectations

A nice bonus would be to switch the new Nimble test suite to Quick.

[Nimble] A "raise" matcher

expect{...}.to.raise()
expect{...}.to.raise(NSRangeException)
expect{...}.to.raise(NSRangeException, reason: "Now you've gone too far!")

I thought this was impossible, since Swift doesn't support try-catching exceptions. But it's actually possible if the matcher is written in Objective-C.

Currently matchers must subclass Matcher. But Matcher is a Swift class that can't be subclassed using Objective-C. So Matcher will have to change to a protocol, and the raise matcher can then conform to that protocol.

beforeSuite/afterSuite are probably not ported to Objective-C

A quick glance at Quick.DSL makes it seem as if beforeSuite and afterSuite are only available in Swift. I'll probably fix this myself during JFK ✈️ NRT (boarding in a few minutes).

Create Callsite struct in Nimble

Callsite should be created in Nimble to break Quick dependency.

[Nimble] beFalse() matcher

it seems for me that expect(sut).to.beFalse() is more human-readable than expect(sut).toNot.beTrue(),
@modocache what do you think?

README: add section on testing view controllers

I forget most of the method names, but basically:

var viewController: MyViewController?
beforeEach {
    let storyboard = UIStoryboard(name: "Main", bundle: nil)
    viewController = storyboard.instantiateStartingViewController() as MyViewController // or instantiateViewControllerNamed something-something...
    _ = viewController.view // trigger `viewDidLoad`
}

I added a lot of examples of testing arbitrary classes to the README, but it would be nice to include examples that demonstrate testing UIKit code.

The added section should continue to use the "dolphin" theme from the rest of the README. The new section should be placed after "Quick Expectations", and should be called "Testing UIKit with Quick", or something.

[Nimble] Unify negative fail messages

The negative fail messages should use either not to or to not. As it is now some use the former while others use the latter. This is likely a result of there being both a notTo and toNot in Quick. We should decide on which one to use for negative fail messages. Either form is grammatically correct English.

Report failures using the correct file and line number

This can be done using -[XCTestCase recordFailureWithDescription:inFile:atLine:expected:], instead of the XCTest assertion macros used by Expectation.swift.

[Quick] Change exampleGroups() to spec()

Really like this library, but I wasn't familiar with the Example/ExampleGroup nomenclature and didn't make the connection to the exampleGroups function overriding. Seems like it would be more appealing to call it something like spec():

class WinterSpec: QuickSpec {
  override class func spec() {
    describe("winter") {
      // Snip...
    }
  }
}

This is completely bike shedding, but I thought I'd throw it out there anyway.

[Nimble] Tests for Expectation, i.e.: test matchers using Raise matcher

An error this huge should never make it past the test suite: 92de94a

Easier installation for iOS/OS X

It'd be great to package Quick so that users can easily add it to their test bundles. Perhaps by having them include it in their Xcode project as a framework?

Add file template for QuickConfiguration subclass

Once shared examples are ported to Objective-C in #80, add a file template for shared example subclasses. Like the spec file template, it should allow users to create a new file using either Swift or Objective-C.

[Nimble] Match (regex) matcher

It should behave as close to the RSpec match matcher as possible: https://www.relishapp.com/rspec/rspec-expectations/v/3-0/docs/built-in-matchers/match-matcher

I haven't written a ton of regular expressions in Objective-C/Swift, so I don't have a lot of experience to draw from, but if creating regular expressions using Foundation is too verbose, the matchers may want to consider supporting strings instead, such as:

expect("867-5309").to.match("\d{3}-\d{4}")

In this case, the string parameter passed to the match method would be converted into a regex by the matcher itself. Just a thought.

Extract Quick.Expectations into separate Xcode project

Quick.Core and Quick.Expectations should not rely on one another at all. One way to enforce this separation is to extract Quick.Expectations into its own project.

Quick.Core is to Specta as Quick.Expectations is to Expecta.

Bonus points if you can come up with a cool name for the Quick.Expectations project.

[Quick, Nimble] Missing XCTest.framework in Xcode 6 Beta 2

After installing Xcode 6 Beta 2, $(DEVELOPER_FRAMEWORKS_DIR) (i.e.: /Applications/Xcode6-Beta2.app/Contents/Developer/Library/Frameworks/) no longer contains XCTest.framework.

Quick and Nimble cannot build because of this missing dependency.

Xcode 6 Beta 1 does contain a reference to the framework, in /Applications/Xcode6-Beta.app/Contents/Developer/Library/Frameworks/. Adding that path to the OS X targets gets them to build, although I don't think that's a long-term solution.

Still working on getting iOS targets to build.

[Nimble] Closure and asynchronous expectation tests

NimbleTests contains tests that use to, notTo, and toNot, but no tests that use will or willNot (there are some tests for these in Quick's test suite).

Add tests to NimbleTests for will and willNot.

[Quick] Test failure errors should include the nested description (add shared examples)

E.g., The failure of the expectation expect(sut.popValue()).to.equal(5) reports: _failed - expected '2' to be equal to '5'. It should give a full description of the failure: **'An integer stack, when created, when I push 5, pops 5.' [FAILED] Expected '5', got '2'**_.

[Quick] Port shared examples DSL to Objective-C

Right now it's only available in Swift. Make sure to add Objective-C samples to the README as well.

Renamed/Deleted test cases appear in Navigator

I suspect this is an Xcode issue, not related to Quick, but when I rename or delete tests from the swift source file, they still appear in the Xcode navigator.

I suspect there is a step that can be used to clear out the test navigators old results, but a Build > Clean doesn't help.

In the attached image, this is the result after a Build > Clean. The ticked items are the only ones remaining in the unit test source file, the others have been removed as the development proceeds.

[Nimble] Contain matcher should test for substring existence

It will be handy to have this behaviour:
expect("foo bar").to.contain("foo") as in https://github.com/specta/expecta

Nimble is terrible

Don't get me wrong, Quick ain't pretty either, but as of #8 Nimble's architecture is a mess. Matchers, Actuals, and Predictions use a sloppy inheritance scheme that is downright cringeworthy. Refactor to favor composition.

Prettier Objective-C syntax

Currently, Objective-C specs in Quick look like this:

// Objective-C

#import <Quick/Quick.h>
#import <Nimble/Nimble.h>

QuickSpecBegin(DolphinSpec)

qck_describe(@"a dolphin", ^{
    __block Dolphin *dolphin = nil;
    qck_beforeEach(^{ dolphin = [Dolphin new]; });

    qck_describe(@"its click", ^{
        qck_context(@"when the dolphin is not near anything interesting", ^{
            qck_it(@"is only emitted once", ^{
                [nmb_expect(@([[dolphin click] count])).to nmb_equal:@1];
            });
        });
    });
});

QuickSpecEnd

There is a lot of room for improvement:

• Allow users to use a "shorthand" which removes the qck_ and nmb_ prefixes
• Remove nmb_ prefix from equal: and contain: matchers
• Remove brackets from Nimble: nmb_expect(@1).to.equal(@1); instead of [nmb_expect(@1).to equal:@1];
• When using autocompletion for qck_it, the block argument is not expanded to ^{}, but rather it is expanded to block. It'd be nice if, when I autocompleted, I got an open block literal, instead of a useless macro variable name.

[Quick] Shared examples not quite there yet

I thought I had implemented #44 but there's a small problem: shared examples need to be registered before any examples are compiled.

The current implementation works when sharing examples within the same spec file, but not among multiple spec files.

Placing them in a beforeSuite doesn't cut it, because while those are executed before any examples are run, there is no guarantee they're executed before any examples are compiled.

Specta gets around the problem by having users define shared example group classes. The shared examples are registered in a global registry during +initialize.