briancroom

I am trying to determine if it is possible to build a Swift dynamic library which is itself composed of one of more private modules, without needing to expose to that fact to outside users. My hope was that I could build the private module as a static library, which would be linked into the primary (dynamic) library. The dylib could then be deployed together with its swiftmodule and swiftdoc and be imported, with the private module and its symbols not being exposed at all.

Unfortunately, what I'm currently observing seems to indicate that the private module's swiftmodule also has to be available for the primary library to be successfully imported.

This can be reproduced as follows. I have the following directory structure:

./Greeter/Logger/Logger.swift:

public func log(_ message: String) {

briancroom

import Promissum
import Nimble

private func stringifyPromise<T, U>(promise: Promise<T, U>) -> String {
    switch promise.result {
    case nil: return "<pending>"
    case let .Value(value)?: return "<resolved: \(value)>"
    case let .Error(error)?: return "<rejected: \(error)>"
    }
}

briancroom

@testable import Nimble

public func matchError<T: ErrorType>(expectedValue: T?) -> NonNilMatcherFunc<ErrorType> {
    return NonNilMatcherFunc { actualExpression, failureMessage in
        defer { failureMessage.postfixMessage = "match <\(T.self).\(stringify(expectedValue))>" }

        if try actualExpression.evaluate() is T {
            return try equal(expectedValue as? NSError).matches(
                actualExpression.cast({ $0 as? NSError }),
                failureMessage: failureMessage

briancroom

import Foundation
import XCTest

// XCTestCaseProvider is defined on Linux as part of swift-corelibs-xctest,
// but is not available on OS X. By defining this protocol and extension
// we ensure that the tests fail on OS X if they haven't been configured properly
// to be run on Linux

#if !os(Linux)

briancroom

#!/usr/bin/python
# Invoke this script with a Swift file containing an XCTestCase and it will
# generate an implementation for the `allTests` variable required for
# XCTestCaseProvider conformance on Linux

import sys
import re

inFile = open(sys.argv[1]) if len(sys.argv) > 1 else sys.stdin

briancroom

import XCTest // import SwiftXCTest

class Test: XCTestCase/*, XCTestCaseProvider*/ {
    var allTests : [(String, () -> Void)] {
        return [
            ("testAssert", testAssert),
            ("testAssertEqualOptionals", testAssertEqualOptionals),
            ("testAssertEqualArraySlices", testAssertEqualArraySlices),
            ("testAssertEqualContiguousArrays", testAssertEqualContiguousArrays),
            ("testAssertEqualArrays", testAssertEqualArrays),

briancroom

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
	<key>CFBundleDevelopmentRegion</key>
	<string>en</string>
	<key>CFBundleExecutable</key>
	<string>$(EXECUTABLE_NAME)</string>
	<key>CFBundleIdentifier</key>
	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>

briancroom

SCHEME=MyApp
PRODUCT_NAME=${SCHEME}
WORKSPACE=${SCHEME}.xcworkspace
SOURCE_ROOT=./
###

ABSOLUTE_SOURCE_ROOT=$(cd $SOURCE_ROOT; pwd)
BUILD_SETTINGS=`xcodebuild -workspace ${WORKSPACE} -scheme ${SCHEME} -sdk iphonesimulator -showBuildSettings`

# Project Temp Root ends up with /Build/Intermediates/

briancroom

#if __has_feature(objc_generics)
#define BC_GENERIC(GENERIC_TYPE) <GENERIC_TYPE>
#define BC_GENERIC_TYPE(GENERIC_TYPE) GENERIC_TYPE
#else
#define BC_GENERIC(GENERIC_TYPE)
#define BC_GENERIC_TYPE(GENERIC_TYPE) id
#endif

briancroom

/**
Response to: http://owensd.io/2015/06/22/catching-errors-for-testing-or-enums-suck.html

After seeing the new features introduced in Xcode 7 beta 2, it seemed that it should be
possible to take David's 4th option one step further. This allows writing assertions
that look exactly as David wishes. The only requirement is that any types used as
associated values on an error enum have to adopt the `DefaultConstructible` protocol
to allow for an instance of the enum case to be created.
**/