diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 1a272da..f31d26b 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -62,34 +62,42 @@ We require that your commit messages match our template. The easiest way to do t ### Make sure Tests work on Linux -SwiftLog uses XCTest to run tests on both macOS and Linux. While the macOS version of XCTest is able to use the Objective-C runtime to discover tests at execution time, the Linux version is not. -For this reason, whenever you add new tests **you have to run a script** that generates the hooks needed to run those tests on Linux, or our CI will complain that the tests are not all present on Linux. To do this, merely execute `ruby ./scripts/generate_linux_tests.rb` at the root of the package and check the changes it made. +SwiftLog uses Swift Testing to run tests on all supported platforms. -### Run `./scripts/soundness.sh` +### Run CI checks locally -The scripts directory contains a [soundness.sh script](https://github.com/apple/swift-log/blob/main/scripts/soundness.sh) -that enforces additional checks, like license headers and formatting style. +You can run the Github Actions workflows locally using +[act](https://github.com/nektos/act). To run all the jobs that run on a pull +request, use the following command: -Please make sure to `./scripts/soundness.sh` before pushing a change upstream, otherwise it is likely the PR validation will fail -on minor changes such as a missing `self.` or similar formatting issues. - -> The script also executes the above mentioned `generate_linux_tests.rb`. - -For frequent contributors, we recommend adding the script as a [git pre-push hook](https://git-scm.com/book/en/v2/Customizing-Git-Git-Hooks), which you can do via executing the following command in the project root directory: - -```bash -cat << EOF > .git/hooks/pre-push -#!/bin/bash - -if [[ -f "scripts/soundness.sh" ]]; then - scripts/soundness.sh -fi -EOF +``` +% act pull_request ``` -Which makes the script execute, and only allow the `git push` to complete if the check has passed. +To run just a single job, use `workflow_call -j `, and specify the inputs +the job expects. For example, to run just shellcheck: -In the case of formatting issues, you can then `git add` the formatting changes, and attempt the push again. +``` +% act workflow_call -j soundness --input shell_check_enabled=true +``` + +To bind-mount the working directory to the container, rather than a copy, use +`--bind`. For example, to run just the formatting, and have the results +reflected in your working directory: + +``` +% act --bind workflow_call -j soundness --input format_check_enabled=true +``` + +If you'd like `act` to always run with certain flags, these can be be placed in +an `.actrc` file either in the current working directory or your home +directory, for example: + +``` +--container-architecture=linux/amd64 +--remote-name upstream +--action-offline-mode +``` ## How to contribute your work diff --git a/NOTICE.txt b/NOTICE.txt index 9462819..ff1b6ca 100644 --- a/NOTICE.txt +++ b/NOTICE.txt @@ -26,15 +26,6 @@ components that this product depends on. ------------------------------------------------------------------------------- -This product contains a derivation of the Tony Stone's 'process_test_files.rb'. - - * LICENSE (Apache License 2.0): - * https://www.apache.org/licenses/LICENSE-2.0 - * HOMEPAGE: - * https://codegists.com/snippet/ruby/generate_xctest_linux_runnerrb_tonystone_ruby - ---- - This product contains a derivation of the lock implementation and various scripts from SwiftNIO. diff --git a/Tests/LoggingTests/CompatibilityTest.swift b/Tests/LoggingTests/CompatibilityTest.swift index 732310d..ca932db 100644 --- a/Tests/LoggingTests/CompatibilityTest.swift +++ b/Tests/LoggingTests/CompatibilityTest.swift @@ -14,11 +14,11 @@ // Not testable import Logging -import XCTest +import Testing -final class CompatibilityTest: XCTestCase { +struct CompatibilityTest { @available(*, deprecated, message: "Testing deprecated functionality") - func testAllLogLevelsWorkWithOldSchoolLogHandlerWorks() { + @Test func allLogLevelsWorkWithOldSchoolLogHandlerWorks() { let testLogging = OldSchoolTestLogging() var logger = Logger(label: "\(#function)", factory: { testLogging.make(label: $0) }) diff --git a/Tests/LoggingTests/GlobalLoggingTest.swift b/Tests/LoggingTests/GlobalLoggingTest.swift index 3f98b98..d2510b5 100644 --- a/Tests/LoggingTests/GlobalLoggingTest.swift +++ b/Tests/LoggingTests/GlobalLoggingTest.swift @@ -13,18 +13,21 @@ //===----------------------------------------------------------------------===// import Dispatch -import XCTest +import Testing @testable import Logging -class GlobalLoggerTest: XCTestCase { - func test1() throws { +/// This is the only test suite allowed to use global LoggingSystem bootstrapping, +/// tests in the suite are executed one by one +@Suite(.serialized) +struct GlobalLoggerTest { + @Test func traceAndAbove() throws { // bootstrap with our test logging impl let logging = TestLogging() LoggingSystem.bootstrapInternal { logging.make(label: $0) } - // change test logging config to log traces and above - logging.config.set(value: Logger.Level.debug) + // change test logging config to log trace and above + logging.config.set(value: Logger.Level.trace) // run our program Struct1().doSomething() // test results @@ -40,12 +43,16 @@ class GlobalLoggerTest: XCTestCase { logging.history.assertExist(level: .debug, message: "Struct3::doSomethingElse::Local", metadata: ["baz": "qux"]) logging.history.assertExist(level: .debug, message: "Struct3::doSomethingElse::end") logging.history.assertExist(level: .debug, message: "Struct3::doSomething::end") + logging.history.assertExist(level: .trace, message: "Struct3::doSomething::end::lastLine") logging.history.assertExist(level: .debug, message: "Struct2::doSomethingElse::end") + logging.history.assertExist(level: .trace, message: "Struct2::doSomethingElse::end::lastLine") logging.history.assertExist(level: .debug, message: "Struct1::doSomethingElse::end") logging.history.assertExist(level: .debug, message: "Struct1::doSomething::end") + logging.history.assertExist(level: .trace, message: "Struct1::doSomething::end::lastLine") + } - func test2() throws { + @Test func errorAndAbove() throws { // bootstrap with our test logging impl let logging = TestLogging() LoggingSystem.bootstrapInternal { logging.make(label: $0) } @@ -75,12 +82,15 @@ class GlobalLoggerTest: XCTestCase { ) logging.history.assertNotExist(level: .debug, message: "Struct3::doSomethingElse::end") logging.history.assertNotExist(level: .debug, message: "Struct3::doSomething::end") + logging.history.assertNotExist(level: .trace, message: "Struct3::doSomething::end::lastLine") logging.history.assertNotExist(level: .debug, message: "Struct2::doSomethingElse::end") + logging.history.assertNotExist(level: .trace, message: "Struct2::doSomethingElse::end::lastLine") logging.history.assertNotExist(level: .debug, message: "Struct1::doSomethingElse::end") logging.history.assertNotExist(level: .debug, message: "Struct1::doSomething::end") + logging.history.assertNotExist(level: .trace, message: "Struct1::doSomething::end::lastLine") } - func test3() throws { + @Test func warningAndAbove() throws { // bootstrap with our test logging impl let logging = TestLogging() LoggingSystem.bootstrapInternal { logging.make(label: $0) } @@ -114,6 +124,96 @@ class GlobalLoggerTest: XCTestCase { } } +/// MetadataProvider tests relying on the global state +extension GlobalLoggerTest { + @Test func loggingMergesOneOffMetadataWithProvidedMetadataFromExplicitlyPassed() throws { + let logging = TestLogging() + + LoggingSystem.bootstrapInternal( + { logging.makeWithMetadataProvider(label: $0, metadataProvider: $1) }, + metadataProvider: .init { + ["common": "initial"] + } + ) + + let logger = Logger( + label: #function, + metadataProvider: .init { + [ + "common": "provider", + "provider": "42", + ] + } + ) + + logger.log(level: .info, "test", metadata: ["one-off": "42", "common": "one-off"]) + + logging.history.assertExist( + level: .info, + message: "test", + metadata: ["common": "one-off", "one-off": "42", "provider": "42"] + ) + } + + @Test func loggerWithoutFactoryOverrideDefaultsToUsingLoggingSystemMetadataProvider() { + let logging = TestLogging() + LoggingSystem.bootstrapInternal( + { logging.makeWithMetadataProvider(label: $0, metadataProvider: $1) }, + metadataProvider: .init { ["provider": "42"] } + ) + + let logger = Logger(label: #function) + + logger.log(level: .info, "test", metadata: ["one-off": "42"]) + + logging.history.assertExist( + level: .info, + message: "test", + metadata: ["provider": "42", "one-off": "42"] + ) + } + + @Test func loggerWithPredefinedLibraryMetadataProvider() { + let logging = TestLogging() + LoggingSystem.bootstrapInternal( + { logging.makeWithMetadataProvider(label: $0, metadataProvider: $1) }, + metadataProvider: .exampleProvider + ) + + let logger = Logger(label: #function) + + logger.log(level: .info, "test", metadata: ["one-off": "42"]) + + logging.history.assertExist( + level: .info, + message: "test", + metadata: ["example": "example-value", "one-off": "42"] + ) + } + + @Test func loggerWithFactoryOverrideDefaultsToUsingLoggingSystemMetadataProvider() { + let logging = TestLogging() + LoggingSystem.bootstrapInternal( + { logging.makeWithMetadataProvider(label: $0, metadataProvider: $1) }, + metadataProvider: .init { ["provider": "42"] } + ) + + let logger = Logger( + label: #function, + factory: { label in + logging.makeWithMetadataProvider(label: label, metadataProvider: LoggingSystem.metadataProvider) + } + ) + logger.log(level: .info, "test", metadata: ["one-off": "42"]) + + logging.history.assertExist( + level: .info, + message: "test", + metadata: ["provider": "42", "one-off": "42"] + ) + } +} + private struct Struct1 { private let logger = Logger(label: "GlobalLoggerTest::Struct1") @@ -127,6 +227,7 @@ private struct Struct1 { self.logger.debug("Struct1::doSomethingElse") Struct2().doSomething() self.logger.debug("Struct1::doSomethingElse::end") + self.logger.trace("Struct1::doSomething::end::lastLine") } } @@ -143,6 +244,7 @@ private struct Struct2 { self.logger.info("Struct2::doSomethingElse") Struct3().doSomething() self.logger.debug("Struct2::doSomethingElse::end") + self.logger.trace("Struct2::doSomethingElse::end::lastLine") } } @@ -154,6 +256,7 @@ private struct Struct3 { self.logger.error("Struct3::doSomething") self.doSomethingElse() self.logger.debug("Struct3::doSomething::end") + self.logger.trace("Struct3::doSomething::end::lastLine") } private func doSomethingElse() { diff --git a/Tests/LoggingTests/LocalLoggingTest.swift b/Tests/LoggingTests/LocalLoggingTest.swift index 375736d..923a6cc 100644 --- a/Tests/LoggingTests/LocalLoggingTest.swift +++ b/Tests/LoggingTests/LocalLoggingTest.swift @@ -13,20 +13,20 @@ //===----------------------------------------------------------------------===// import Dispatch -import XCTest +import Testing @testable import Logging -class LocalLoggerTest: XCTestCase { - func test1() throws { - // bootstrap with our test logging impl +struct LocalLoggerTest { + @Test func traceAndAbove() throws { + // create test logging impl, do not bootstrap global LoggingSystem let logging = TestLogging() - LoggingSystem.bootstrapInternal { logging.make(label: $0) } - // change test logging config to log traces and above - logging.config.set(value: Logger.Level.debug) + // change global test logging config to log trace and above, + // local logging context will be modified to debug + logging.config.set(value: Logger.Level.trace) // run our program - let context = Context() + let context = Context { logging.make(label: $0) } Struct1().doSomething(context: context) // test results logging.history.assertExist(level: .debug, message: "Struct1::doSomething", source: "LoggingTests") @@ -36,29 +36,33 @@ class LocalLoggerTest: XCTestCase { logging.history.assertExist(level: .error, message: "Struct3::doSomething", metadata: ["bar": "baz"]) logging.history.assertExist(level: .error, message: "Struct3::doSomethingElse", metadata: ["bar": "baz"]) logging.history.assertExist(level: .warning, message: "Struct3::doSomethingElseAsync", metadata: ["bar": "baz"]) - logging.history.assertExist(level: .info, message: "TestLibrary::doSomething") - logging.history.assertExist(level: .info, message: "TestLibrary::doSomethingAsync") logging.history.assertExist( level: .debug, message: "Struct3::doSomethingElse::Local", metadata: ["bar": "baz", "baz": "qux"] ) logging.history.assertExist(level: .debug, message: "Struct3::doSomethingElse::end", metadata: ["bar": "baz"]) + logging.history.assertNotExist( + level: .trace, + message: "Struct3::doSomethingElse::end::lastLine", + metadata: ["bar": "baz"] + ) logging.history.assertExist(level: .debug, message: "Struct3::doSomething::end", metadata: ["bar": "baz"]) logging.history.assertExist(level: .debug, message: "Struct2::doSomethingElse::end") + logging.history.assertNotExist(level: .trace, message: "Struct2::doSomethingElse::end::lastLine") logging.history.assertExist(level: .debug, message: "Struct1::doSomethingElse::end") + logging.history.assertNotExist(level: .trace, message: "Struct1::doSomethingElse::end::lastLine") logging.history.assertExist(level: .debug, message: "Struct1::doSomething::end") } - func test2() throws { - // bootstrap with our test logging impl + @Test func errorAndAbove() throws { + // create test logging impl, do not bootstrap global LoggingSystem let logging = TestLogging() - LoggingSystem.bootstrapInternal { logging.make(label: $0) } // change test logging config to log errors and above logging.config.set(value: Logger.Level.error) // run our program - let context = Context() + let context = Context { logging.make(label: $0) } Struct1().doSomething(context: context) // test results // global context @@ -79,20 +83,27 @@ class LocalLoggerTest: XCTestCase { logging.history.assertNotExist(level: .info, message: "TestLibrary::doSomething") // global context logging.history.assertNotExist(level: .info, message: "TestLibrary::doSomethingAsync") - // hyper local context + // hyper local .debug context logging.history.assertExist( level: .debug, message: "Struct3::doSomethingElse::Local", metadata: ["bar": "baz", "baz": "qux"] ) - // local context + // local .debug context logging.history.assertExist(level: .debug, message: "Struct3::doSomethingElse::end", metadata: ["bar": "baz"]) - // local context + logging.history.assertNotExist( + level: .trace, + message: "Struct3::doSomethingElse::end::lastLine", + metadata: ["bar": "baz"] + ) + // local .debug context logging.history.assertExist(level: .debug, message: "Struct2::doSomethingElse::end") + logging.history.assertNotExist(level: .trace, message: "Struct2::doSomethingElse::end::lastLine") // local context logging.history.assertExist(level: .debug, message: "Struct3::doSomething::end", metadata: ["bar": "baz"]) // global context logging.history.assertNotExist(level: .debug, message: "Struct1::doSomethingElse::end") + logging.history.assertNotExist(level: .trace, message: "Struct1::doSomethingElse::end::lastLine") // global context logging.history.assertNotExist(level: .debug, message: "Struct1::doSomething::end") } @@ -100,7 +111,11 @@ class LocalLoggerTest: XCTestCase { // systems that follow the context pattern need to implement something like this private struct Context { - var logger = Logger(label: "LocalLoggerTest::ContextLogger") + var logger: Logger + + init(_ factory: (String) -> any LogHandler) { + self.logger = Logger(label: "LocalLoggerTest::ContextLogger", factory: factory) + } // since logger is a value type, we can reuse our copy to manage logLevel var logLevel: Logger.Level { @@ -147,6 +162,7 @@ private struct Struct2 { c.logger.info("Struct2::doSomethingElse") Struct3().doSomething(context: c) c.logger.debug("Struct2::doSomethingElse::end") + c.logger.trace("Struct2::doSomethingElse::end::lastLine") } } @@ -159,6 +175,7 @@ private struct Struct3 { c.logger.error("Struct3::doSomething") self.doSomethingElse(context: c) c.logger.debug("Struct3::doSomething::end") + c.logger.trace("Struct3::doSomething::end::lastLine") } private func doSomethingElse(context: Context) { @@ -179,5 +196,6 @@ private struct Struct3 { l[metadataKey: "baz"] = "qux" l.debug("Struct3::doSomethingElse::Local") context.logger.debug("Struct3::doSomethingElse::end") + context.logger.trace("Struct3::doSomethingElse::end::lastLine") } } diff --git a/Tests/LoggingTests/LoggingTest.swift b/Tests/LoggingTests/LoggingTest.swift index 50447ae..d390774 100644 --- a/Tests/LoggingTests/LoggingTest.swift +++ b/Tests/LoggingTests/LoggingTest.swift @@ -12,7 +12,8 @@ // //===----------------------------------------------------------------------===// -import XCTest +import Foundation +import Testing @testable import Logging @@ -40,30 +41,34 @@ extension LogHandler { } } -class LoggingTest: XCTestCase { - func testAutoclosure() throws { - // bootstrap with our test logging impl +struct LoggingTest { + @Test func autoclosure() throws { + // create test logging impl, do not bootstrap global LoggingSystem let logging = TestLogging() - LoggingSystem.bootstrapInternal { logging.make(label: $0) } - var logger = Logger(label: "test") + var logger = Logger( + label: "test", + factory: { + logging.make(label: $0) + } + ) logger.logLevel = .info logger.log( level: .debug, { - XCTFail("debug should not be called") + Issue.record("debug should not be called") return "debug" }() ) logger.trace( { - XCTFail("trace should not be called") + Issue.record("trace should not be called") return "trace" }() ) logger.debug( { - XCTFail("debug should not be called") + Issue.record("debug should not be called") return "debug" }() ) @@ -82,7 +87,7 @@ class LoggingTest: XCTestCase { "error" }() ) - XCTAssertEqual(3, logging.history.entries.count, "expected number of entries to match") + #expect(3 == logging.history.entries.count, "expected number of entries to match") logging.history.assertNotExist(level: .debug, message: "trace") logging.history.assertNotExist(level: .debug, message: "debug") logging.history.assertExist(level: .info, message: "info") @@ -90,13 +95,17 @@ class LoggingTest: XCTestCase { logging.history.assertExist(level: .error, message: "error") } - func testMultiplex() throws { - // bootstrap with our test logging impl + @Test func multiplex() throws { + // create test logging impl, do not bootstrap global LoggingSystem let logging1 = TestLogging() let logging2 = TestLogging() - LoggingSystem.bootstrapInternal { MultiplexLogHandler([logging1.make(label: $0), logging2.make(label: $0)]) } - var logger = Logger(label: "test") + var logger = Logger( + label: "test", + factory: { + MultiplexLogHandler([logging1.make(label: $0), logging2.make(label: $0)]) + } + ) logger.logLevel = .warning logger.info("hello world?") logger[metadataKey: "foo"] = "bar" @@ -107,18 +116,19 @@ class LoggingTest: XCTestCase { logging2.history.assertExist(level: .warning, message: "hello world!", metadata: ["foo": "bar"]) } - func testMultiplexLogHandlerWithVariousLogLevels() throws { + @Test func multiplexLogHandlerWithVariousLogLevels() throws { let logging1 = TestLogging() let logging2 = TestLogging() let logger1 = logging1.make(label: "1").with(logLevel: .info) let logger2 = logging2.make(label: "2").with(logLevel: .debug) - LoggingSystem.bootstrapInternal { _ in - MultiplexLogHandler([logger1, logger2]) - } - - let multiplexLogger = Logger(label: "test") + let multiplexLogger = Logger( + label: "test", + factory: { _ in + MultiplexLogHandler([logger1, logger2]) + } + ) multiplexLogger.trace("trace") multiplexLogger.debug("debug") multiplexLogger.info("info") @@ -135,21 +145,22 @@ class LoggingTest: XCTestCase { logging2.history.assertExist(level: .warning, message: "warning") } - func testMultiplexLogHandlerNeedNotMaterializeValuesMultipleTimes() throws { + @Test func multiplexLogHandlerNeedNotMaterializeValuesMultipleTimes() throws { let logging1 = TestLogging() let logging2 = TestLogging() let logger1 = logging1.make(label: "1").with(logLevel: .info) let logger2 = logging2.make(label: "2").with(logLevel: .info) - LoggingSystem.bootstrapInternal { _ in - MultiplexLogHandler([logger1, logger2]) - } - var messageMaterializations: Int = 0 var metadataMaterializations: Int = 0 - let multiplexLogger = Logger(label: "test") + let multiplexLogger = Logger( + label: "test", + factory: { _ in + MultiplexLogHandler([logger1, logger2]) + } + ) multiplexLogger.info( { () -> Logger.Message in messageMaterializations += 1 @@ -164,11 +175,11 @@ class LoggingTest: XCTestCase { logging1.history.assertExist(level: .info, message: "info") logging2.history.assertExist(level: .info, message: "info") - XCTAssertEqual(messageMaterializations, 1) - XCTAssertEqual(metadataMaterializations, 1) + #expect(messageMaterializations == 1) + #expect(metadataMaterializations == 1) } - func testMultiplexLogHandlerMetadata_settingMetadataThroughToUnderlyingHandlers() { + @Test func multiplexLogHandlerMetadata_settingMetadataThroughToUnderlyingHandlers() { let logging1 = TestLogging() let logging2 = TestLogging() @@ -179,11 +190,12 @@ class LoggingTest: XCTestCase { .withMetadata("two", "222") .withMetadata("in", "in-2") - LoggingSystem.bootstrapInternal { _ in - MultiplexLogHandler([logger1, logger2]) - } - - var multiplexLogger = Logger(label: "test") + var multiplexLogger = Logger( + label: "test", + factory: { _ in + MultiplexLogHandler([logger1, logger2]) + } + ) // each logs its own metadata multiplexLogger.info("info") @@ -249,7 +261,7 @@ class LoggingTest: XCTestCase { ) } - func testMultiplexLogHandlerMetadata_readingHandlerMetadata() { + @Test func multiplexLogHandlerMetadata_readingHandlerMetadata() { let logging1 = TestLogging() let logging2 = TestLogging() @@ -260,15 +272,15 @@ class LoggingTest: XCTestCase { .withMetadata("two", "222") .withMetadata("in", "in-2") - LoggingSystem.bootstrapInternal { _ in - MultiplexLogHandler([logger1, logger2]) - } + let multiplexLogger = Logger( + label: "test", + factory: { _ in + MultiplexLogHandler([logger1, logger2]) + } + ) - let multiplexLogger = Logger(label: "test") - - XCTAssertEqual( - multiplexLogger.handler.metadata, - [ + #expect( + multiplexLogger.handler.metadata == [ "one": "111", "two": "222", "in": "in-2", @@ -276,7 +288,7 @@ class LoggingTest: XCTestCase { ) } - func testMultiplexMetadataProviderSet() { + @Test func multiplexMetadataProviderSet() { let logging1 = TestLogging() let logging2 = TestLogging() @@ -301,15 +313,15 @@ class LoggingTest: XCTestCase { return handler2 }() - LoggingSystem.bootstrapInternal { _ in - MultiplexLogHandler([handler1, handler2]) - } + let multiplexLogger = Logger( + label: "test", + factory: { _ in + MultiplexLogHandler([handler1, handler2]) + } + ) - let multiplexLogger = Logger(label: "test") - - XCTAssertEqual( - multiplexLogger.handler.metadata, - [ + #expect( + multiplexLogger.handler.metadata == [ "one": "111", "two": "222", "in": "in-2", @@ -318,9 +330,8 @@ class LoggingTest: XCTestCase { "provider-overlap": "provided-222", ] ) - XCTAssertEqual( - multiplexLogger.handler.metadataProvider?.get(), - [ + #expect( + multiplexLogger.handler.metadataProvider?.get() == [ "provider-1": "provided-111", "provider-2": "provided-222", "provider-overlap": "provided-222", @@ -328,7 +339,7 @@ class LoggingTest: XCTestCase { ) } - func testMultiplexMetadataProviderExtract() { + @Test func multiplexMetadataProviderExtract() { let logging1 = TestLogging() let logging2 = TestLogging() @@ -351,25 +362,22 @@ class LoggingTest: XCTestCase { return handler2 }() - LoggingSystem.bootstrapInternal( - { _, metadataProvider in + let multiplexLogger = Logger( + label: "test", + factory: { _ in MultiplexLogHandler( [handler1, handler2], - metadataProvider: metadataProvider + metadataProvider: .constant([ + "provider-overlap": "provided-outer" + ]) ) - }, - metadataProvider: .constant([ - "provider-overlap": "provided-outer" - ]) + } ) - let multiplexLogger = Logger(label: "test") - let provider = multiplexLogger.metadataProvider! - XCTAssertEqual( - provider.get(), - [ + #expect( + provider.get() == [ "provider-1": "provided-111", "provider-2": "provided-222", "provider-overlap": "provided-outer", @@ -381,11 +389,15 @@ class LoggingTest: XCTestCase { case boom } - func testDictionaryMetadata() { + @Test func dictionaryMetadata() { let testLogging = TestLogging() - LoggingSystem.bootstrapInternal { testLogging.make(label: $0) } - var logger = Logger(label: "\(#function)") + var logger = Logger( + label: "\(#function)", + factory: { + testLogging.make(label: $0) + } + ) logger[metadataKey: "foo"] = ["bar": "buz"] logger[metadataKey: "empty-dict"] = [:] logger[metadataKey: "nested-dict"] = ["l1key": ["l2key": ["l3key": "l3value"]]] @@ -401,11 +413,15 @@ class LoggingTest: XCTestCase { ) } - func testListMetadata() { + @Test func listMetadata() { let testLogging = TestLogging() - LoggingSystem.bootstrapInternal { testLogging.make(label: $0) } - var logger = Logger(label: "\(#function)") + var logger = Logger( + label: "\(#function)", + factory: { + testLogging.make(label: $0) + } + ) logger[metadataKey: "foo"] = ["bar", "buz"] logger[metadataKey: "empty-list"] = [] logger[metadataKey: "nested-list"] = ["l1str", ["l2str1", "l2str2"]] @@ -448,10 +464,14 @@ class LoggingTest: XCTestCase { } } - func testStringConvertibleMetadata() { + @Test func stringConvertibleMetadata() { let testLogging = TestLogging() - LoggingSystem.bootstrapInternal { testLogging.make(label: $0) } - var logger = Logger(label: "\(#function)") + var logger = Logger( + label: "\(#function)", + factory: { + testLogging.make(label: $0) + } + ) logger[metadataKey: "foo"] = .stringConvertible("raw-string") let lazyBox = LazyMetadataBox { "rendered-at-first-use" } @@ -467,16 +487,28 @@ class LoggingTest: XCTestCase { ) } - private func dontEvaluateThisString(file: StaticString = #filePath, line: UInt = #line) -> Logger.Message { - XCTFail("should not have been evaluated", file: file, line: line) + private func dontEvaluateThisString( + fileID: String = #fileID, + file: StaticString = #filePath, + line: UInt = #line, + column: UInt = #column + ) -> Logger.Message { + Issue.record( + "should not have been evaluated", + sourceLocation: SourceLocation(fileID: fileID, filePath: "\(file)", line: Int(line), column: Int(column)) + ) return "should not have been evaluated" } - func testAutoClosuresAreNotForcedUnlessNeeded() { + @Test func autoClosuresAreNotForcedUnlessNeeded() { let testLogging = TestLogging() - LoggingSystem.bootstrapInternal { testLogging.make(label: $0) } - var logger = Logger(label: "\(#function)") + var logger = Logger( + label: "\(#function)", + factory: { + testLogging.make(label: $0) + } + ) logger.logLevel = .error logger.debug(self.dontEvaluateThisString(), metadata: ["foo": "\(self.dontEvaluateThisString())"]) @@ -486,11 +518,15 @@ class LoggingTest: XCTestCase { logger.log(level: .warning, self.dontEvaluateThisString()) } - func testLocalMetadata() { + @Test func localMetadata() { let testLogging = TestLogging() - LoggingSystem.bootstrapInternal { testLogging.make(label: $0) } - var logger = Logger(label: "\(#function)") + var logger = Logger( + label: "\(#function)", + factory: { + testLogging.make(label: $0) + } + ) logger.info("hello world!", metadata: ["foo": "bar"]) logger[metadataKey: "bar"] = "baz" logger[metadataKey: "baz"] = "qux" @@ -505,7 +541,7 @@ class LoggingTest: XCTestCase { testLogging.history.assertExist(level: .error, message: "hello world!", metadata: ["bar": "baz", "baz": "quc"]) } - func testCustomFactory() { + @Test func customFactory() { struct CustomHandler: LogHandler { func log( level: Logger.Level, @@ -534,16 +570,20 @@ class LoggingTest: XCTestCase { } let logger1 = Logger(label: "foo") - XCTAssertFalse(logger1.handler is CustomHandler, "expected non-custom log handler") + #expect(!(logger1.handler is CustomHandler), "expected non-custom log handler") let logger2 = Logger(label: "foo", factory: { _ in CustomHandler() }) - XCTAssertTrue(logger2.handler is CustomHandler, "expected custom log handler") + #expect(logger2.handler is CustomHandler, "expected custom log handler") } - func testAllLogLevelsExceptCriticalCanBeBlocked() { + @Test func allLogLevelsExceptCriticalCanBeBlocked() { let testLogging = TestLogging() - LoggingSystem.bootstrapInternal { testLogging.make(label: $0) } - var logger = Logger(label: "\(#function)") + var logger = Logger( + label: "\(#function)", + factory: { + testLogging.make(label: $0) + } + ) logger.logLevel = .critical logger.trace("no") @@ -563,11 +603,15 @@ class LoggingTest: XCTestCase { testLogging.history.assertExist(level: .critical, message: "yes: critical") } - func testAllLogLevelsWork() { + @Test func allLogLevelsWork() { let testLogging = TestLogging() - LoggingSystem.bootstrapInternal { testLogging.make(label: $0) } - var logger = Logger(label: "\(#function)") + var logger = Logger( + label: "\(#function)", + factory: { + testLogging.make(label: $0) + } + ) logger.logLevel = .trace logger.trace("yes: trace") @@ -587,11 +631,15 @@ class LoggingTest: XCTestCase { testLogging.history.assertExist(level: .critical, message: "yes: critical") } - func testAllLogLevelByFunctionRefWithSource() { + @Test func allLogLevelByFunctionRefWithSource() { let testLogging = TestLogging() - LoggingSystem.bootstrapInternal { testLogging.make(label: $0) } - var logger = Logger(label: "\(#function)") + var logger = Logger( + label: "\(#function)", + factory: { + testLogging.make(label: $0) + } + ) logger.logLevel = .trace let trace = logger.trace(_:metadata:source:file:function:line:) @@ -619,11 +667,15 @@ class LoggingTest: XCTestCase { testLogging.history.assertExist(level: .critical, message: "yes: critical", source: "foo") } - func testAllLogLevelByFunctionRefWithoutSource() { + @Test func allLogLevelByFunctionRefWithoutSource() { let testLogging = TestLogging() - LoggingSystem.bootstrapInternal { testLogging.make(label: $0) } - var logger = Logger(label: "\(#function)") + var logger = Logger( + label: "\(#function)", + factory: { + testLogging.make(label: $0) + } + ) logger.logLevel = .trace let trace = logger.trace(_:metadata:file:function:line:) @@ -651,11 +703,15 @@ class LoggingTest: XCTestCase { testLogging.history.assertExist(level: .critical, message: "yes: critical") } - func testLogsEmittedFromSubdirectoryGetCorrectModuleInNewerSwifts() { + @Test func logsEmittedFromSubdirectoryGetCorrectModuleInNewerSwifts() { let testLogging = TestLogging() - LoggingSystem.bootstrapInternal { testLogging.make(label: $0) } - var logger = Logger(label: "\(#function)") + var logger = Logger( + label: "\(#function)", + factory: { + testLogging.make(label: $0) + } + ) logger.logLevel = .trace emitLogMessage("hello", to: logger) @@ -671,11 +727,15 @@ class LoggingTest: XCTestCase { testLogging.history.assertExist(level: .critical, message: "hello", source: moduleName) } - func testLogMessageWithStringInterpolation() { + @Test func logMessageWithStringInterpolation() { let testLogging = TestLogging() - LoggingSystem.bootstrapInternal { testLogging.make(label: $0) } - var logger = Logger(label: "\(#function)") + var logger = Logger( + label: "\(#function)", + factory: { + testLogging.make(label: $0) + } + ) logger.logLevel = .debug let someInt = Int.random(in: 23..<42) @@ -686,11 +746,15 @@ class LoggingTest: XCTestCase { ) } - func testLoggingAString() { + @Test func loggingAString() { let testLogging = TestLogging() - LoggingSystem.bootstrapInternal { testLogging.make(label: $0) } - var logger = Logger(label: "\(#function)") + var logger = Logger( + label: "\(#function)", + factory: { + testLogging.make(label: $0) + } + ) logger.logLevel = .debug let anActualString: String = "hello world!" @@ -702,7 +766,7 @@ class LoggingTest: XCTestCase { testLogging.history.assertExist(level: .debug, message: "hello world!") } - func testMultiplexMetadataProviderMergesInSpecifiedOrder() { + @Test func multiplexMetadataProviderMergesInSpecifiedOrder() { let logging = TestLogging() let providerA = Logger.MetadataProvider { ["provider": "a", "a": "foo"] } @@ -723,87 +787,30 @@ class LoggingTest: XCTestCase { ) } - func testLoggerWithoutFactoryOverrideDefaultsToUsingLoggingSystemMetadataProvider() { - let logging = TestLogging() - LoggingSystem.bootstrapInternal( - { logging.makeWithMetadataProvider(label: $0, metadataProvider: $1) }, - metadataProvider: .init { ["provider": "42"] } - ) - - let logger = Logger(label: #function) - - logger.log(level: .info, "test", metadata: ["one-off": "42"]) - - logging.history.assertExist( - level: .info, - message: "test", - metadata: ["provider": "42", "one-off": "42"] - ) - } - - func testLoggerWithPredefinedLibraryMetadataProvider() { - let logging = TestLogging() - LoggingSystem.bootstrapInternal( - { logging.makeWithMetadataProvider(label: $0, metadataProvider: $1) }, - metadataProvider: .exampleProvider - ) - - let logger = Logger(label: #function) - - logger.log(level: .info, "test", metadata: ["one-off": "42"]) - - logging.history.assertExist( - level: .info, - message: "test", - metadata: ["example": "example-value", "one-off": "42"] - ) - } - - func testLoggerWithFactoryOverrideDefaultsToUsingLoggingSystemMetadataProvider() { - let logging = TestLogging() - LoggingSystem.bootstrapInternal( - { logging.makeWithMetadataProvider(label: $0, metadataProvider: $1) }, - metadataProvider: .init { ["provider": "42"] } - ) - - let logger = Logger( - label: #function, - factory: { label in - logging.makeWithMetadataProvider(label: label, metadataProvider: LoggingSystem.metadataProvider) - } - ) - - logger.log(level: .info, "test", metadata: ["one-off": "42"]) - - logging.history.assertExist( - level: .info, - message: "test", - metadata: ["provider": "42", "one-off": "42"] - ) - } - - func testMultiplexerIsValue() { + @Test func multiplexerIsValue() { let multi = MultiplexLogHandler([ StreamLogHandler.standardOutput(label: "x"), StreamLogHandler.standardOutput(label: "y"), ]) - LoggingSystem.bootstrapInternal { _ in - print("new multi") - return multi - } let logger1: Logger = { - var logger = Logger(label: "foo") + var logger = Logger( + label: "foo", + factory: { _ in + print("new multi") + return multi + } + ) logger.logLevel = .debug logger[metadataKey: "only-on"] = "first" return logger }() - XCTAssertEqual(.debug, logger1.logLevel) + #expect(.debug == logger1.logLevel) var logger2 = logger1 logger2.logLevel = .error logger2[metadataKey: "only-on"] = "second" - XCTAssertEqual(.error, logger2.logLevel) - XCTAssertEqual(.debug, logger1.logLevel) - XCTAssertEqual("first", logger1[metadataKey: "only-on"]) - XCTAssertEqual("second", logger2[metadataKey: "only-on"]) + #expect(.error == logger2.logLevel) + #expect(.debug == logger1.logLevel) + #expect("first" == logger1[metadataKey: "only-on"]) + #expect("second" == logger2[metadataKey: "only-on"]) logger1.error("hey") } @@ -834,7 +841,7 @@ class LoggingTest: XCTestCase { } } - func testLoggerWithGlobalOverride() { + @Test func loggerWithGlobalOverride() { struct LogHandlerWithGlobalLogLevelOverride: LogHandler { // the static properties hold the globally overridden log level (if overridden) private static let overrideLogLevel = LockedValueBox(initialValue: nil) @@ -890,20 +897,22 @@ class LoggingTest: XCTestCase { } let logRecorder = Recorder() - LoggingSystem.bootstrapInternal { _ in - LogHandlerWithGlobalLogLevelOverride(recorder: logRecorder) - } - var logger1 = Logger(label: "logger-\(#file):\(#line)") + var logger1 = Logger( + label: "logger-\(#file):\(#line)", + factory: { _ in + LogHandlerWithGlobalLogLevelOverride(recorder: logRecorder) + } + ) var logger2 = logger1 logger1.logLevel = .warning logger1[metadataKey: "only-on"] = "first" logger2.logLevel = .error logger2[metadataKey: "only-on"] = "second" - XCTAssertEqual(.error, logger2.logLevel) - XCTAssertEqual(.warning, logger1.logLevel) - XCTAssertEqual("first", logger1[metadataKey: "only-on"]) - XCTAssertEqual("second", logger2[metadataKey: "only-on"]) + #expect(.error == logger2.logLevel) + #expect(.warning == logger1.logLevel) + #expect("first" == logger1[metadataKey: "only-on"]) + #expect("second" == logger2[metadataKey: "only-on"]) logger1.notice("logger1, before") logger2.notice("logger2, before") @@ -919,33 +928,33 @@ class LoggingTest: XCTestCase { logRecorder.assertExist(level: .notice, message: "logger2, after") } - func testLogLevelCases() { + @Test func logLevelCases() { let levels = Logger.Level.allCases - XCTAssertEqual(7, levels.count) + #expect(7 == levels.count) } - func testLogLevelOrdering() { - XCTAssertLessThan(Logger.Level.trace, Logger.Level.debug) - XCTAssertLessThan(Logger.Level.trace, Logger.Level.info) - XCTAssertLessThan(Logger.Level.trace, Logger.Level.notice) - XCTAssertLessThan(Logger.Level.trace, Logger.Level.warning) - XCTAssertLessThan(Logger.Level.trace, Logger.Level.error) - XCTAssertLessThan(Logger.Level.trace, Logger.Level.critical) - XCTAssertLessThan(Logger.Level.debug, Logger.Level.info) - XCTAssertLessThan(Logger.Level.debug, Logger.Level.notice) - XCTAssertLessThan(Logger.Level.debug, Logger.Level.warning) - XCTAssertLessThan(Logger.Level.debug, Logger.Level.error) - XCTAssertLessThan(Logger.Level.debug, Logger.Level.critical) - XCTAssertLessThan(Logger.Level.info, Logger.Level.notice) - XCTAssertLessThan(Logger.Level.info, Logger.Level.warning) - XCTAssertLessThan(Logger.Level.info, Logger.Level.error) - XCTAssertLessThan(Logger.Level.info, Logger.Level.critical) - XCTAssertLessThan(Logger.Level.notice, Logger.Level.warning) - XCTAssertLessThan(Logger.Level.notice, Logger.Level.error) - XCTAssertLessThan(Logger.Level.notice, Logger.Level.critical) - XCTAssertLessThan(Logger.Level.warning, Logger.Level.error) - XCTAssertLessThan(Logger.Level.warning, Logger.Level.critical) - XCTAssertLessThan(Logger.Level.error, Logger.Level.critical) + @Test func logLevelOrdering() { + #expect(Logger.Level.trace < Logger.Level.debug) + #expect(Logger.Level.trace < Logger.Level.info) + #expect(Logger.Level.trace < Logger.Level.notice) + #expect(Logger.Level.trace < Logger.Level.warning) + #expect(Logger.Level.trace < Logger.Level.error) + #expect(Logger.Level.trace < Logger.Level.critical) + #expect(Logger.Level.debug < Logger.Level.info) + #expect(Logger.Level.debug < Logger.Level.notice) + #expect(Logger.Level.debug < Logger.Level.warning) + #expect(Logger.Level.debug < Logger.Level.error) + #expect(Logger.Level.debug < Logger.Level.critical) + #expect(Logger.Level.info < Logger.Level.notice) + #expect(Logger.Level.info < Logger.Level.warning) + #expect(Logger.Level.info < Logger.Level.error) + #expect(Logger.Level.info < Logger.Level.critical) + #expect(Logger.Level.notice < Logger.Level.warning) + #expect(Logger.Level.notice < Logger.Level.error) + #expect(Logger.Level.notice < Logger.Level.critical) + #expect(Logger.Level.warning < Logger.Level.error) + #expect(Logger.Level.warning < Logger.Level.critical) + #expect(Logger.Level.error < Logger.Level.critical) } final class InterceptStream: TextOutputStream { @@ -959,12 +968,14 @@ class LoggingTest: XCTestCase { } } - func testStreamLogHandlerWritesToAStream() { + @Test func streamLogHandlerWritesToAStream() { let interceptStream = InterceptStream() - LoggingSystem.bootstrapInternal { _ in - StreamLogHandler(label: "test", stream: interceptStream) - } - let log = Logger(label: "test") + let log = Logger( + label: "test", + factory: { + StreamLogHandler(label: $0, stream: interceptStream) + } + ) let testString = "my message is better than yours" log.critical("\(testString)") @@ -972,18 +983,20 @@ class LoggingTest: XCTestCase { let messageSucceeded = interceptStream.interceptedText?.trimmingCharacters(in: .whitespacesAndNewlines) .hasSuffix(testString) - XCTAssertTrue(messageSucceeded ?? false) - XCTAssertEqual(interceptStream.strings.count, 1) + #expect(messageSucceeded ?? false) + #expect(interceptStream.strings.count == 1) } - func testStreamLogHandlerOutputFormat() { + @Test func streamLogHandlerOutputFormat() { let interceptStream = InterceptStream() let label = "testLabel" - LoggingSystem.bootstrapInternal { label in - StreamLogHandler(label: label, stream: interceptStream) - } let source = "testSource" - let log = Logger(label: label) + let log = Logger( + label: label, + factory: { + StreamLogHandler(label: $0, stream: interceptStream) + } + ) let testString = "my message is better than yours" log.critical("\(testString)", source: source) @@ -997,17 +1010,19 @@ class LoggingTest: XCTestCase { options: .regularExpression ) != nil - XCTAssertTrue(messageSucceeded) - XCTAssertEqual(interceptStream.strings.count, 1) + #expect(messageSucceeded) + #expect(interceptStream.strings.count == 1) } - func testStreamLogHandlerOutputFormatWithEmptyLabel() { + @Test func streamLogHandlerOutputFormatWithEmptyLabel() { let interceptStream = InterceptStream() - LoggingSystem.bootstrapInternal { label in - StreamLogHandler(label: label, stream: interceptStream) - } let source = "testSource" - let log = Logger(label: "") + let log = Logger( + label: "", + factory: { + StreamLogHandler(label: $0, stream: interceptStream) + } + ) let testString = "my message is better than yours" log.critical("\(testString)", source: source) @@ -1021,18 +1036,20 @@ class LoggingTest: XCTestCase { options: .regularExpression ) != nil - XCTAssertTrue(messageSucceeded) - XCTAssertEqual(interceptStream.strings.count, 1) + #expect(messageSucceeded) + #expect(interceptStream.strings.count == 1) } - func testStreamLogHandlerOutputFormatWithMetaData() { + @Test func streamLogHandlerOutputFormatWithMetaData() { let interceptStream = InterceptStream() let label = "testLabel" - LoggingSystem.bootstrapInternal { label in - StreamLogHandler(label: label, stream: interceptStream) - } let source = "testSource" - let log = Logger(label: label) + let log = Logger( + label: label, + factory: { + StreamLogHandler(label: $0, stream: interceptStream) + } + ) let testString = "my message is better than yours" log.critical("\(testString)", metadata: ["test": "test"], source: source) @@ -1046,41 +1063,41 @@ class LoggingTest: XCTestCase { options: .regularExpression ) != nil - XCTAssertTrue(messageSucceeded) - XCTAssertEqual(interceptStream.strings.count, 1) + #expect(messageSucceeded) + #expect(interceptStream.strings.count == 1) } - func testStreamLogHandlerOutputFormatWithOrderedMetadata() { + @Test func streamLogHandlerOutputFormatWithOrderedMetadata() { let interceptStream = InterceptStream() - let label = "testLabel" - LoggingSystem.bootstrapInternal { label in - StreamLogHandler(label: label, stream: interceptStream) - } - let log = Logger(label: label) + let log = Logger( + label: "testLabel", + factory: { + StreamLogHandler(label: $0, stream: interceptStream) + } + ) let testString = "my message is better than yours" log.critical("\(testString)", metadata: ["a": "a0", "b": "b0"]) log.critical("\(testString)", metadata: ["b": "b1", "a": "a1"]) - XCTAssertEqual(interceptStream.strings.count, 2) + #expect(interceptStream.strings.count == 2) guard interceptStream.strings.count == 2 else { - XCTFail("Intercepted \(interceptStream.strings.count) logs, expected 2") + Issue.record("Intercepted \(interceptStream.strings.count) logs, expected 2") return } - XCTAssert(interceptStream.strings[0].contains("a=a0 b=b0"), "LINES: \(interceptStream.strings[0])") - XCTAssert(interceptStream.strings[1].contains("a=a1 b=b1"), "LINES: \(interceptStream.strings[1])") + #expect(interceptStream.strings[0].contains("a=a0 b=b0"), "LINES: \(interceptStream.strings[0])") + #expect(interceptStream.strings[1].contains("a=a1 b=b1"), "LINES: \(interceptStream.strings[1])") } - func testStreamLogHandlerWritesIncludeMetadataProviderMetadata() { + @Test func streamLogHandlerWritesIncludeMetadataProviderMetadata() { let interceptStream = InterceptStream() - LoggingSystem.bootstrapInternal( - { _, metadataProvider in - StreamLogHandler(label: "test", stream: interceptStream, metadataProvider: metadataProvider) - }, - metadataProvider: .exampleProvider + let log = Logger( + label: "test", + factory: { + StreamLogHandler(label: $0, stream: interceptStream, metadataProvider: .exampleProvider) + } ) - let log = Logger(label: "test") let testString = "my message is better than yours" log.critical("\(testString)") @@ -1088,17 +1105,21 @@ class LoggingTest: XCTestCase { let messageSucceeded = interceptStream.interceptedText?.trimmingCharacters(in: .whitespacesAndNewlines) .hasSuffix(testString) - XCTAssertTrue(messageSucceeded ?? false) - XCTAssertEqual(interceptStream.strings.count, 1) + #expect(messageSucceeded ?? false) + #expect(interceptStream.strings.count == 1) let message = interceptStream.strings.first! - XCTAssertTrue(message.contains("example=example-value"), "message must contain metadata, was: \(message)") + #expect(message.contains("example=example-value"), "message must contain metadata, was: \(message)") } - func testStdioOutputStreamWrite() { + @Test func stdioOutputStreamWrite() { self.withWriteReadFDsAndReadBuffer { writeFD, readFD, readBuffer in let logStream = StdioOutputStream(file: writeFD, flushMode: .always) - LoggingSystem.bootstrapInternal { StreamLogHandler(label: $0, stream: logStream) } - let log = Logger(label: "test") + let log = Logger( + label: "test", + factory: { + StreamLogHandler(label: $0, stream: logStream) + } + ) let testString = "hello\u{0} world" log.critical("\(testString)") @@ -1113,23 +1134,27 @@ class LoggingTest: XCTestCase { as: UTF8.self ) let messageSucceeded = output.trimmingCharacters(in: .whitespacesAndNewlines).hasSuffix(testString) - XCTAssertTrue(messageSucceeded) + #expect(messageSucceeded) } } - func testStdioOutputStreamFlush() { + @Test func stdioOutputStreamFlush() { // flush on every statement self.withWriteReadFDsAndReadBuffer { writeFD, readFD, readBuffer in let logStream = StdioOutputStream(file: writeFD, flushMode: .always) - LoggingSystem.bootstrapInternal { StreamLogHandler(label: $0, stream: logStream) } - Logger(label: "test").critical("test") + Logger( + label: "test", + factory: { + StreamLogHandler(label: $0, stream: logStream) + } + ).critical("test") #if os(Windows) let size = _read(readFD, readBuffer, 256) #else let size = read(readFD, readBuffer, 256) #endif - XCTAssertGreaterThan(size, -1, "expected flush") + #expect(size > -1, "expected flush") logStream.flush() @@ -1138,20 +1163,24 @@ class LoggingTest: XCTestCase { #else let size2 = read(readFD, readBuffer, 256) #endif - XCTAssertEqual(size2, -1, "expected no flush") + #expect(size2 == -1, "expected no flush") } // default flushing self.withWriteReadFDsAndReadBuffer { writeFD, readFD, readBuffer in let logStream = StdioOutputStream(file: writeFD, flushMode: .undefined) - LoggingSystem.bootstrapInternal { StreamLogHandler(label: $0, stream: logStream) } - Logger(label: "test").critical("test") + Logger( + label: "test", + factory: { + StreamLogHandler(label: $0, stream: logStream) + } + ).critical("test") #if os(Windows) let size = _read(readFD, readBuffer, 256) #else let size = read(readFD, readBuffer, 256) #endif - XCTAssertEqual(size, -1, "expected no flush") + #expect(size == -1, "expected no flush") logStream.flush() @@ -1160,7 +1189,7 @@ class LoggingTest: XCTestCase { #else let size2 = read(readFD, readBuffer, 256) #endif - XCTAssertGreaterThan(size2, -1, "expected flush") + #expect(size2 > -1, "expected flush") } } @@ -1169,19 +1198,19 @@ class LoggingTest: XCTestCase { #if os(Windows) fds.withUnsafeMutableBufferPointer { let err = _pipe($0.baseAddress, 256, _O_BINARY) - XCTAssertEqual(err, 0, "_pipe failed \(err)") + #expect(err == 0, "_pipe failed \(err)") } guard let writeFD = _fdopen(fds[1], "w") else { - XCTFail("Failed to open file") + Issue.record("Failed to open file") return } #else fds.withUnsafeMutableBufferPointer { ptr in let err = pipe(ptr.baseAddress!) - XCTAssertEqual(err, 0, "pipe failed \(err)") + #expect(err == 0, "pipe failed \(err)") } guard let writeFD = fdopen(fds[1], "w") else { - XCTFail("Failed to open file") + Issue.record("Failed to open file") return } #endif @@ -1193,19 +1222,19 @@ class LoggingTest: XCTestCase { } var err = setvbuf(writeFD, writeBuffer, _IOFBF, 256) - XCTAssertEqual(err, 0, "setvbuf failed \(err)") + #expect(err == 0, "setvbuf failed \(err)") let readFD = fds[0] #if os(Windows) let hPipe: HANDLE = HANDLE(bitPattern: _get_osfhandle(readFD))! - XCTAssertFalse(hPipe == INVALID_HANDLE_VALUE) + #expect(hPipe != INVALID_HANDLE_VALUE) var dwMode: DWORD = DWORD(PIPE_NOWAIT) let bSucceeded = SetNamedPipeHandleState(hPipe, &dwMode, nil, nil) - XCTAssertTrue(bSucceeded) + #expect(bSucceeded) #else err = fcntl(readFD, F_SETFL, fcntl(readFD, F_GETFL) | O_NONBLOCK) - XCTAssertEqual(err, 0, "fcntl failed \(err)") + #expect(err == 0, "fcntl failed \(err)") #endif let readBuffer = UnsafeMutablePointer.allocate(capacity: 256) @@ -1226,24 +1255,28 @@ class LoggingTest: XCTestCase { } } - func testOverloadingError() { + @Test func overloadingError() { struct Dummy: Error, LocalizedError { var errorDescription: String? { "errorDescription" } } - // bootstrap with our test logging impl + // create test logging impl, do not bootstrap global LoggingSystem let logging = TestLogging() - LoggingSystem.bootstrapInternal { logging.make(label: $0) } - var logger = Logger(label: "test") + var logger = Logger( + label: "test", + factory: { + logging.make(label: $0) + } + ) logger.logLevel = .error logger.error(error: Dummy()) logging.history.assertExist(level: .error, message: "errorDescription") } - func testCompileInitializeStandardStreamLogHandlersWithMetadataProviders() { + @Test func compileInitializeStandardStreamLogHandlersWithMetadataProviders() { // avoid "unreachable code" warnings let dontExecute = Int.random(in: 100...200) == 1 guard dontExecute else { @@ -1283,18 +1316,18 @@ class LoggingTest: XCTestCase { ) } - func testLoggerIsJustHoldingASinglePointer() { + @Test func loggerIsJustHoldingASinglePointer() { let expectedSize = MemoryLayout.size - XCTAssertEqual(MemoryLayout.size, expectedSize) + #expect(MemoryLayout.size == expectedSize) } - func testLoggerCopyOnWrite() { + @Test func loggerCopyOnWrite() { var logger1 = Logger(label: "foo") logger1.logLevel = .error var logger2 = logger1 logger2.logLevel = .trace - XCTAssertEqual(.error, logger1.logLevel) - XCTAssertEqual(.trace, logger2.logLevel) + #expect(.error == logger1.logLevel) + #expect(.trace == logger2.logLevel) } } diff --git a/Tests/LoggingTests/MDCTest.swift b/Tests/LoggingTests/MDCTest.swift index 18c0005..a2e3cb5 100644 --- a/Tests/LoggingTests/MDCTest.swift +++ b/Tests/LoggingTests/MDCTest.swift @@ -12,16 +12,12 @@ // //===----------------------------------------------------------------------===// import Dispatch -import XCTest +import Testing @testable import Logging -class MDCTest: XCTestCase { - func test1() throws { - // bootstrap with our test logger - let logging = TestLogging() - LoggingSystem.bootstrapInternal { logging.make(label: $0) } - +struct MDCTest { + @Test func test() throws { // run the program MDC.global["foo"] = "bar" let group = DispatchGroup() @@ -36,20 +32,20 @@ class MDCTest: XCTestCase { for i in 0...remove { MDC.global["key-\(i)"] = nil } - XCTAssertEqual(add - remove, MDC.global.metadata.count, "expected number of entries to match") + #expect((add - remove) == MDC.global.metadata.count, "expected number of entries to match") for i in remove + 1...add { - XCTAssertNotNil(MDC.global["key-\(i)"], "expecting value for key-\(i)") + #expect(MDC.global["key-\(i)"] != nil, "expecting value for key-\(i)") } for i in 0...remove { - XCTAssertNil(MDC.global["key-\(i)"], "not expecting value for key-\(i)") + #expect(MDC.global["key-\(i)"] == nil, "not expecting value for key-\(i)") } MDC.global.clear() group.leave() } } group.wait() - XCTAssertEqual(MDC.global["foo"], "bar", "expecting to find top items") + #expect(MDC.global["foo"] == "bar", "expecting to find top items") MDC.global["foo"] = nil - XCTAssertTrue(MDC.global.metadata.isEmpty, "MDC should be empty") + #expect(MDC.global.metadata.isEmpty, "MDC should be empty") } } diff --git a/Tests/LoggingTests/MetadataProviderTest.swift b/Tests/LoggingTests/MetadataProviderTest.swift index 5dbdd9c..7ce7e3e 100644 --- a/Tests/LoggingTests/MetadataProviderTest.swift +++ b/Tests/LoggingTests/MetadataProviderTest.swift @@ -12,7 +12,7 @@ // //===----------------------------------------------------------------------===// -import XCTest +import Testing @testable import Logging @@ -26,36 +26,8 @@ import Android import Glibc #endif -final class MetadataProviderTest: XCTestCase { - func testLoggingMergesOneOffMetadataWithProvidedMetadataFromExplicitlyPassed() throws { - let logging = TestLogging() - LoggingSystem.bootstrapInternal( - { logging.makeWithMetadataProvider(label: $0, metadataProvider: $1) }, - metadataProvider: .init { - ["common": "initial"] - } - ) - - let logger = Logger( - label: #function, - metadataProvider: .init { - [ - "common": "provider", - "provider": "42", - ] - } - ) - - logger.log(level: .info, "test", metadata: ["one-off": "42", "common": "one-off"]) - - logging.history.assertExist( - level: .info, - message: "test", - metadata: ["common": "one-off", "one-off": "42", "provider": "42"] - ) - } - - func testLogHandlerThatDidNotImplementProvidersButSomeoneAttemptsToSetOneOnIt() { +struct MetadataProviderTest { + @Test func logHandlerThatDidNotImplementProvidersButSomeoneAttemptsToSetOneOnIt() { #if DEBUG // we only emit these warnings in debug mode let logging = TestLogging() @@ -72,11 +44,11 @@ final class MetadataProviderTest: XCTestCase { let countBefore = logging.history.entries.count handler.metadataProvider = .simpleTestProvider - XCTAssertEqual(countBefore, logging.history.entries.count, "Should only log the warning once") + #expect(countBefore == logging.history.entries.count, "Should only log the warning once") #endif } - func testLogHandlerThatDidImplementProvidersButSomeoneAttemptsToSetOneOnIt() { + @Test func logHandlerThatDidImplementProvidersButSomeoneAttemptsToSetOneOnIt() { #if DEBUG // we only emit these warnings in debug mode let logging = TestLogging() diff --git a/Tests/LoggingTests/TestLogger.swift b/Tests/LoggingTests/TestLogger.swift index 731ae9c..7d6258a 100644 --- a/Tests/LoggingTests/TestLogger.swift +++ b/Tests/LoggingTests/TestLogger.swift @@ -14,7 +14,7 @@ import Dispatch import Foundation -import XCTest +import Testing @testable import Logging @@ -22,7 +22,7 @@ import XCTest import WinSDK #endif -internal struct TestLogging { +struct TestLogging { private let _config = Config() // shared among loggers private let recorder = Recorder() // shared among loggers @@ -233,17 +233,17 @@ extension History { message: String, metadata: Logger.Metadata? = nil, source: String? = nil, - file: StaticString = #filePath, + file: String = #filePath, fileID: String = #fileID, - line: UInt = #line + line: Int = #line, + column: Int = #column ) { let source = source ?? Logger.currentModule(fileID: "\(fileID)") let entry = self.find(level: level, message: message, metadata: metadata, source: source) - XCTAssertNotNil( - entry, + #expect( + entry != nil, "entry not found: \(level), \(source), \(String(describing: metadata)), \(message)", - file: file, - line: line + sourceLocation: SourceLocation(fileID: fileID, filePath: file, line: line, column: column) ) } @@ -252,17 +252,17 @@ extension History { message: String, metadata: Logger.Metadata? = nil, source: String? = nil, - file: StaticString = #filePath, + file: String = #filePath, fileID: String = #file, - line: UInt = #line + line: Int = #line, + column: Int = #column ) { let source = source ?? Logger.currentModule(fileID: "\(fileID)") let entry = self.find(level: level, message: message, metadata: metadata, source: source) - XCTAssertNil( - entry, + #expect( + entry == nil, "entry was found: \(level), \(source), \(String(describing: metadata)), \(message)", - file: file, - line: line + sourceLocation: SourceLocation(fileID: fileID, filePath: file, line: line, column: column) ) } @@ -302,6 +302,7 @@ extension History { } } +/// MDC stands for Mapped Diagnostic Context public class MDC { private let lock = NSLock() private var storage = [Int: Logger.Metadata]() @@ -380,16 +381,6 @@ public class MDC { } } -extension NSLock { - func withLock(_ body: () -> T) -> T { - self.lock() - defer { - self.unlock() - } - return body() - } -} - internal struct TestLibrary: Sendable { private let logger = Logger(label: "TestLibrary") private let queue = DispatchQueue(label: "TestLibrary") diff --git a/Tests/LoggingTests/TestSendable.swift b/Tests/LoggingTests/TestSendable.swift index 5348dc5..a6b4fa2 100644 --- a/Tests/LoggingTests/TestSendable.swift +++ b/Tests/LoggingTests/TestSendable.swift @@ -12,16 +12,20 @@ // //===----------------------------------------------------------------------===// -import XCTest +import Testing @testable import Logging -class SendableTest: XCTestCase { - func testSendableLogger() async { +struct SendableTest { + @Test func sendableLogger() async { let testLogging = TestLogging() - LoggingSystem.bootstrapInternal { testLogging.make(label: $0) } - let logger = Logger(label: "test") + let logger = Logger( + label: "test", + factory: { + testLogging.make(label: $0) + } + ) let message1 = Logger.Message(stringLiteral: "critical 1") let message2 = Logger.Message(stringLiteral: "critical 2") let metadata: Logger.Metadata = ["key": "value"]