diff --git a/Package.resolved b/Package.resolved index da830b18..8ccf8439 100644 --- a/Package.resolved +++ b/Package.resolved @@ -1,5 +1,5 @@ { - "originHash" : "b0016fe2158c6ff94782073523d09f304acc60fa7f2acd6594ef897839490a51", + "originHash" : "ad1e5434846a92c0dac225a6a8db318f8511f8c5743706cc40109d7f9ae5a10e", "pins" : [ { "identity" : "darwinprivateframeworks", @@ -7,7 +7,7 @@ "location" : "https://github.com/OpenSwiftUIProject/DarwinPrivateFrameworks.git", "state" : { "branch" : "main", - "revision" : "867d9c17ffbb5fc433ea2841caefd7c2dc258fe4" + "revision" : "e12014b79f31a1483d7633f188c520fdf40f79c1" } }, { diff --git a/Package.swift b/Package.swift index 8e9bdf4f..34561526 100644 --- a/Package.swift +++ b/Package.swift @@ -196,15 +196,6 @@ let openGraphCompatibilityTestTarget = Target.testTarget( cSettings: sharedCSettings, swiftSettings: sharedSwiftSettings ) -let openGraphSPICompatibilityTestTarget = Target.testTarget( - name: "OpenGraph_SPICompatibilityTests", - dependencies: [ - .product(name: "Numerics", package: "swift-numerics"), - ], - exclude: ["README.md"], - cSettings: sharedCSettings, - swiftSettings: sharedSwiftSettings -) // MARK: - Package @@ -226,7 +217,6 @@ let package = Package( openGraphSPITestTarget, openGraphShimsTestTarget, openGraphCompatibilityTestTarget, - openGraphSPICompatibilityTestTarget, ], cxxLanguageStandard: .cxx20 ) @@ -278,10 +268,8 @@ if attributeGraphCondition { let compatibilityTestCondition = envEnable("OPENGRAPH_COMPATIBILITY_TEST") if compatibilityTestCondition && attributeGraphCondition { openGraphCompatibilityTestTarget.addCompatibilitySettings() - openGraphSPICompatibilityTestTarget.addCompatibilitySettings() } else { openGraphCompatibilityTestTarget.dependencies.append("OpenGraph") - openGraphSPICompatibilityTestTarget.dependencies.append("OpenGraph") } extension [Platform] { diff --git a/Sources/OpenGraph_SPI/Graph/OGGraphTracing.cpp b/Sources/OpenGraph_SPI/Graph/OGGraphTracing.cpp new file mode 100644 index 00000000..94a1e40a --- /dev/null +++ b/Sources/OpenGraph_SPI/Graph/OGGraphTracing.cpp @@ -0,0 +1,17 @@ +// +// OGGraphTracing.mm +// OpenGraph_SPI + +#include "OGGraphTracing.h" + +void OGGraphStartTracing(_Nullable OGGraphRef graph, OGGraphTraceFlags options) { + OGGraphStartTracing2(graph, options, NULL); +} + +void OGGraphStartTracing2(_Nullable OGGraphRef graph, OGGraphTraceFlags options, _Nullable CFArrayRef array) { + // TODO +} + +void OGGraphStopTracing(_Nullable OGGraphRef graph) { + // TODO +} diff --git a/Sources/OpenGraph_SPI/include/OGGraphTracing.h b/Sources/OpenGraph_SPI/include/OGGraphTracing.h new file mode 100644 index 00000000..b77307da --- /dev/null +++ b/Sources/OpenGraph_SPI/include/OGGraphTracing.h @@ -0,0 +1,37 @@ +// +// OGGraphTracing.h +// OpenGraph_SPI + +#ifndef OGGraphTracing_hpp +#define OGGraphTracing_hpp + +#include "OGBase.h" +#include "OGGraph.h" + +typedef OG_OPTIONS(uint32_t, OGGraphTraceFlags) { + OGGraphTraceFlags_0 = 0, + OGGraphTraceFlags_1 = 1 << 0, + OGGraphTraceFlags_2 = 1 << 1, +} OG_SWIFT_NAME(OGGraphRef.TraceFlags); + +OG_ASSUME_NONNULL_BEGIN + +OG_EXTERN_C_BEGIN + +OG_EXPORT +OG_REFINED_FOR_SWIFT +void OGGraphStartTracing(_Nullable OGGraphRef graph, OGGraphTraceFlags options) OG_SWIFT_NAME(OGGraphRef.startTracing(_:options:)); + +OG_EXPORT +OG_REFINED_FOR_SWIFT +void OGGraphStartTracing2(_Nullable OGGraphRef graph, OGGraphTraceFlags options, _Nullable CFArrayRef array); + +OG_EXPORT +OG_REFINED_FOR_SWIFT +void OGGraphStopTracing(_Nullable OGGraphRef graph) OG_SWIFT_NAME(OGGraphRef.stopTracing(_:)); + +OG_EXTERN_C_END + +OG_ASSUME_NONNULL_END + +#endif /* OGGraphTracing_hpp */ diff --git a/Sources/OpenGraph_SPI/include/OpenGraph-umbrella.h b/Sources/OpenGraph_SPI/include/OpenGraph-umbrella.h index 6dba3eda..be50e9fc 100644 --- a/Sources/OpenGraph_SPI/include/OpenGraph-umbrella.h +++ b/Sources/OpenGraph_SPI/include/OpenGraph-umbrella.h @@ -12,6 +12,7 @@ #include "OGDebugServer.h" #include "OGGraph.h" #include "OGGraphContext.h" +#include "OGGraphTracing.h" #include "OGInputOptions.h" #include "OGSearchOptions.h" #include "OGSubgraph.h" diff --git a/Tests/OpenGraphCompatibilityTests/Graph/GraphTests.swift b/Tests/OpenGraphCompatibilityTests/Graph/GraphTests.swift index b12ed1fe..0bde8719 100644 --- a/Tests/OpenGraphCompatibilityTests/Graph/GraphTests.swift +++ b/Tests/OpenGraphCompatibilityTests/Graph/GraphTests.swift @@ -1,8 +1,6 @@ // // GraphTests.swift -// -// -// +// OpenGraphCompatibilityTests import Testing import Foundation diff --git a/Tests/OpenGraphCompatibilityTests/Graph/GraphTracingTests.swift b/Tests/OpenGraphCompatibilityTests/Graph/GraphTracingTests.swift new file mode 100644 index 00000000..7782c2ab --- /dev/null +++ b/Tests/OpenGraphCompatibilityTests/Graph/GraphTracingTests.swift @@ -0,0 +1,26 @@ +// +// GraphTracingTests.swift +// OpenGraphCompatibilityTests + +import Testing + +struct GraphTracingTests { + @Test + func tracing() { + let graph = Graph() + Graph.startTracing(graph, options: []) + Graph.stopTracing(graph) + } + + @Test + func tracingAll() { + Graph.startTracing(nil, options: []) + Graph.stopTracing(nil) + } + + @Test + func options() { + let option = Graph.TraceFlags(rawValue: 1) + #expect(option == ._1) + } +} diff --git a/Tests/OpenGraphCompatibilityTests/Runtime/MetadataTests.swift b/Tests/OpenGraphCompatibilityTests/Runtime/MetadataTests.swift index 4e1aef5b..d7ae11d1 100644 --- a/Tests/OpenGraphCompatibilityTests/Runtime/MetadataTests.swift +++ b/Tests/OpenGraphCompatibilityTests/Runtime/MetadataTests.swift @@ -4,26 +4,153 @@ import Testing +@Suite(.enabled(if: swiftToolchainSupported)) struct MetadataTests { class T1 { var a = 0 var b: Double = 0 } - + struct T2 { var a: Int var b: Double } - + enum T3 { case a, b } - + + enum T4: Equatable { + case none + case empty + case int(Int) + case double(Double) + } + protocol P { var a: Int { get } var b: Double { get } } - + + @Test + func kind() { + #expect(Metadata(T1.self).kind == .class) + #expect(Metadata(T2.self).kind == .struct) + #expect(Metadata(T3.self).kind == .enum) + + #expect(Metadata(Void?.self).kind == .optional) + #expect(Metadata(Int?.self).kind == .optional) + #expect(Metadata(T1?.self).kind == .optional) + #expect(Metadata((T1, T2)?.self).kind == .optional) + + #expect(Metadata(Void.self).kind == .tuple) + #expect(Metadata((Int, Double?).self).kind == .tuple) + #expect(Metadata((T1, T2, T3).self).kind == .tuple) + + #expect(Metadata((() -> Void).self).kind == .function) + + #expect(Metadata(P.self).kind == .existential) + #expect(Metadata((any P).self).kind == .existential) + + #expect(Metadata(P.Protocol.self).kind == .metatype) + #expect(Metadata(type(of: Int.self)).kind == .metatype) + } + + @Test + func enumType() { + var none = T4.none + var empty = T4.empty + var int = T4.int(1) + var double = T4.double(2.0) + let metadata = Metadata(T4.self) + + withUnsafePointer(to: none) { #expect(metadata.enumTag($0) == 2) } + withUnsafePointer(to: empty) { #expect(metadata.enumTag($0) == 3) } + withUnsafePointer(to: int) { #expect(metadata.enumTag($0) == 0) } + withUnsafePointer(to: double) { #expect(metadata.enumTag($0) == 1) } + + withUnsafeMutablePointer(to: &int) { + metadata.projectEnumData($0) + #expect(UnsafeMutableRawPointer($0).assumingMemoryBound(to: Int.self).pointee == 1) + } + withUnsafeMutablePointer(to: &double) { + metadata.projectEnumData($0) + #expect(UnsafeMutableRawPointer($0).assumingMemoryBound(to: Double.self).pointee.isApproximatelyEqual(to: 2.0)) + } + withUnsafeMutablePointer(to: &none) { + #expect($0.pointee == .none) + metadata.injectEnumTag(tag: 3, $0) + #expect($0.pointee == .empty) + } + withUnsafeMutablePointer(to: &empty) { + #expect($0.pointee == .empty) + metadata.injectEnumTag(tag: 2, $0) + #expect($0.pointee == .none) + } + withUnsafeMutablePointer(to: &int) { + #expect($0.pointee == .int(1)) + + metadata.injectEnumTag(tag: 1, $0) + #expect(metadata.enumTag($0) == 1) + #expect($0.pointee == .double(Double(bitPattern: 1))) + + metadata.injectEnumTag(tag: 2, $0) + #expect($0.pointee == .none) + + metadata.injectEnumTag(tag: 3, $0) + #expect($0.pointee == .empty) + } + } + + #if OPENGRAPH_SUPPORT_2024_API + func descriptor() { + let t1 = Metadata(T1.self).descriptor + let t2 = Metadata(T2.self).descriptor + let t3 = Metadata(T3.self).descriptor + let p = Metadata(P.self).descriptor + let optionalP = Metadata(P?.self).descriptor + + #expect(t1 != nil) + #expect(t2 != nil) + #expect(t3 != nil) + + #expect(p == nil) + #expect(optionalP != nil) + + #expect(t1 == Metadata(T1.self).descriptor) + } + #endif + + @Test + func nominalDescriptor() { + let t1 = Metadata(T1.self).nominalDescriptor + let t2 = Metadata(T2.self).nominalDescriptor + let t3 = Metadata(T3.self).nominalDescriptor + let p = Metadata(P.self).nominalDescriptor + let optionalP = Metadata(P?.self).nominalDescriptor + + #expect(t1 == nil) + #expect(t2 != nil) + #expect(t3 != nil) + #expect(p == nil) + #expect(optionalP != nil) + } + + @Test + func nominalDescriptorName() throws { + let t1 = Metadata(T1.self).nominalDescriptorName + let t2 = Metadata(T2.self).nominalDescriptorName + let t3 = Metadata(T3.self).nominalDescriptorName + let p = Metadata(P.self).nominalDescriptorName + let optionalP = Metadata(P?.self).nominalDescriptorName + + #expect(t1 == nil) + try #expect(String(cString: #require(t2)) == "T2") + try #expect(String(cString: #require(t3)) == "T3") + #expect(p == nil) + try #expect(String(cString: #require(optionalP)) == "Optional") + } + @Test(.disabled(if: !compatibilityTestEnabled, "Metadata is not implemented")) func description() { #expect(Metadata(T1.self).description == "MetadataTests.T1") diff --git a/Tests/OpenGraphCompatibilityTests/Runtime/TupleTypeTests.swift b/Tests/OpenGraphCompatibilityTests/Runtime/TupleTypeTests.swift index 1b15b4fe..fb63e44c 100644 --- a/Tests/OpenGraphCompatibilityTests/Runtime/TupleTypeTests.swift +++ b/Tests/OpenGraphCompatibilityTests/Runtime/TupleTypeTests.swift @@ -10,16 +10,57 @@ struct TupleTypeTests { var a = 0 var b: Double = 0 } - + struct T2 { var a: Int = 0 var b: Double = 0 } - + enum T3 { case a, b } - + + @Test + func newTupleType() { + let elements: [Metadata] = [Metadata(T1.self), Metadata(T2.self), Metadata(T3.self)] + let tupleType = TupleType(count: 3, elements: elements) + #expect(tupleType.rawValue == Metadata((T1, T2, T3).self).rawValue) + } + + @Test + func tupleCount() { + #expect(TupleType(T1.self).count == 1) + #expect(TupleType([T1.self, T2.self]).count == 2) + #expect(TupleType([T1.self, T2.self, T3.self]).count == 3) + } + + @Test + func tupleSize() { + #expect(TupleType(T1.self).size == 8) + #expect(TupleType([T1.self, T2.self]).size == 24) + #expect(TupleType([T1.self, T2.self, T3.self]).size == 25) + } + + @Test + func tupleElement() { + let tupleType = TupleType([T1.self, T2.self, T3.self]) + #expect(tupleType.elementType(at: 0) == Metadata(T1.self)) + #expect(tupleType.elementType(at: 1) == Metadata(T2.self)) + #expect(tupleType.elementType(at: 2) == Metadata(T3.self)) + + #expect(tupleType.elementSize(at: 0) == 8) + #expect(tupleType.elementSize(at: 1) == 16) + #expect(tupleType.elementSize(at: 2) == 1) + + #expect(tupleType.elementOffset(at: 0) == 0) + #expect(tupleType.elementOffset(at: 1) == 8) + #expect(tupleType.elementOffset(at: 2) == 24) + + #expect(tupleType.elementOffset(at: 0, type: Metadata(T1.self)) == 0) + #expect(tupleType.elementOffset(at: 1, type: Metadata(T2.self)) == 8) + #expect(tupleType.elementOffset(at: 2, type: Metadata(T3.self)) == 24) + } + @Test func initType() { #expect(TupleType(T1.self).rawValue == Metadata(T1.self).rawValue) diff --git a/Tests/OpenGraph_SPICompatibilityTests/GraphShims.swift b/Tests/OpenGraph_SPICompatibilityTests/GraphShims.swift deleted file mode 100644 index c2eca69e..00000000 --- a/Tests/OpenGraph_SPICompatibilityTests/GraphShims.swift +++ /dev/null @@ -1,34 +0,0 @@ -// -// GraphShims.swift -// OpenGraphCompatibilityTests - -#if OPENGRAPH_COMPATIBILITY_TEST -@_exported public import AttributeGraph -public typealias OGAttributeFlags = AGAttributeFlags -public typealias OGAttributeInfo = AGAttributeInfo -public typealias OGAttributeType = AGAttributeType -public typealias OGAttributeTypeFlags = AGAttributeTypeFlags -public typealias OGCachedValueOptions = AGCachedValueOptions -public typealias OGChangedValueFlags = AGChangedValueFlags -public typealias OGComparisonMode = AGComparisonMode -public typealias OGComparisonOptions = AGComparisonOptions -public typealias OGCounterQueryType = AGCounterQueryType -public typealias OGDebugServer = AGDebugServer -public typealias OGInputOptions = AGInputOptions -public typealias OGSearchOptions = AGSearchOptions -public typealias OGTypeApplyOptions = AGTypeApplyOptions -public typealias OGUniqueID = AGUniqueID -public typealias OGValue = AGValue -public typealias OGValueOptions = AGValueOptions -public typealias OGValueState = AGValueState -public let compatibilityTestEnabled = true -public let swiftToolchainSupported = true -#else -@_exported import OpenGraph -let compatibilityTestEnabled = false -#if OPENGRAPH_SWIFT_TOOLCHAIN_SUPPORTED -public let swiftToolchainSupported = true -#else -public let swiftToolchainSupported = false -#endif -#endif diff --git a/Tests/OpenGraph_SPICompatibilityTests/README.md b/Tests/OpenGraph_SPICompatibilityTests/README.md deleted file mode 100644 index 39e18c3a..00000000 --- a/Tests/OpenGraph_SPICompatibilityTests/README.md +++ /dev/null @@ -1,7 +0,0 @@ -## OpenGraphCompatibilityTests - -Test public API of OpenGraph_SPI and run it against with AttributeGraph on Apple Platform. - -The current supported OS -- macOS 14 (CI Supported) -- iOS 15 ~ 17 on Simulator (CI is not supported) diff --git a/Tests/OpenGraph_SPICompatibilityTests/Runtime/MetadataTests.swift b/Tests/OpenGraph_SPICompatibilityTests/Runtime/MetadataTests.swift deleted file mode 100644 index fcfc0d8d..00000000 --- a/Tests/OpenGraph_SPICompatibilityTests/Runtime/MetadataTests.swift +++ /dev/null @@ -1,159 +0,0 @@ -// -// MetadataTests.swift -// OpenGraph_SPICompatibilityTests - -import Testing -import Numerics - -@Suite(.enabled(if: swiftToolchainSupported)) -struct MetadataTests { - class T1 { - var a = 0 - var b: Double = 0 - } - - struct T2 { - var a: Int - var b: Double - } - - enum T3 { - case a, b - } - - enum T4: Equatable { - case none - case empty - case int(Int) - case double(Double) - } - - protocol P { - var a: Int { get } - var b: Double { get } - } - - @Test - func kind() { - #expect(Metadata(T1.self).kind == .class) - #expect(Metadata(T2.self).kind == .struct) - #expect(Metadata(T3.self).kind == .enum) - - #expect(Metadata(Void?.self).kind == .optional) - #expect(Metadata(Int?.self).kind == .optional) - #expect(Metadata(T1?.self).kind == .optional) - #expect(Metadata((T1, T2)?.self).kind == .optional) - - #expect(Metadata(Void.self).kind == .tuple) - #expect(Metadata((Int, Double?).self).kind == .tuple) - #expect(Metadata((T1, T2, T3).self).kind == .tuple) - - #expect(Metadata((() -> Void).self).kind == .function) - - #expect(Metadata(P.self).kind == .existential) - #expect(Metadata((any P).self).kind == .existential) - - #expect(Metadata(P.Protocol.self).kind == .metatype) - #expect(Metadata(type(of: Int.self)).kind == .metatype) - } - - @Test - func enumType() { - var none = T4.none - var empty = T4.empty - var int = T4.int(1) - var double = T4.double(2.0) - let metadata = Metadata(T4.self) - - withUnsafePointer(to: none) { #expect(metadata.enumTag($0) == 2) } - withUnsafePointer(to: empty) { #expect(metadata.enumTag($0) == 3) } - withUnsafePointer(to: int) { #expect(metadata.enumTag($0) == 0) } - withUnsafePointer(to: double) { #expect(metadata.enumTag($0) == 1) } - - withUnsafeMutablePointer(to: &int) { - metadata.projectEnumData($0) - #expect(UnsafeMutableRawPointer($0).assumingMemoryBound(to: Int.self).pointee == 1) - } - withUnsafeMutablePointer(to: &double) { - metadata.projectEnumData($0) - #expect(UnsafeMutableRawPointer($0).assumingMemoryBound(to: Double.self).pointee.isApproximatelyEqual(to: 2.0)) - } - withUnsafeMutablePointer(to: &none) { - #expect($0.pointee == .none) - metadata.injectEnumTag(tag: 3, $0) - #expect($0.pointee == .empty) - } - withUnsafeMutablePointer(to: &empty) { - #expect($0.pointee == .empty) - metadata.injectEnumTag(tag: 2, $0) - #expect($0.pointee == .none) - } - withUnsafeMutablePointer(to: &int) { - #expect($0.pointee == .int(1)) - - metadata.injectEnumTag(tag: 1, $0) - #expect(metadata.enumTag($0) == 1) - #expect($0.pointee == .double(Double(bitPattern: 1))) - - metadata.injectEnumTag(tag: 2, $0) - #expect($0.pointee == .none) - - metadata.injectEnumTag(tag: 3, $0) - #expect($0.pointee == .empty) - } - } - - #if OPENGRAPH_SUPPORT_2024_API - func descriptor() { - let t1 = Metadata(T1.self).descriptor - let t2 = Metadata(T2.self).descriptor - let t3 = Metadata(T3.self).descriptor - let p = Metadata(P.self).descriptor - let optionalP = Metadata(P?.self).descriptor - - #expect(t1 != nil) - #expect(t2 != nil) - #expect(t3 != nil) - - #expect(p == nil) - #expect(optionalP != nil) - - #expect(t1 == Metadata(T1.self).descriptor) - } - #endif - - @Test - func nominalDescriptor() { - let t1 = Metadata(T1.self).nominalDescriptor - let t2 = Metadata(T2.self).nominalDescriptor - let t3 = Metadata(T3.self).nominalDescriptor - let p = Metadata(P.self).nominalDescriptor - let optionalP = Metadata(P?.self).nominalDescriptor - - #expect(t1 == nil) - #expect(t2 != nil) - #expect(t3 != nil) - #expect(p == nil) - #expect(optionalP != nil) - } - - @Test - func nominalDescriptorName() throws { - let t1 = Metadata(T1.self).nominalDescriptorName - let t2 = Metadata(T2.self).nominalDescriptorName - let t3 = Metadata(T3.self).nominalDescriptorName - let p = Metadata(P.self).nominalDescriptorName - let optionalP = Metadata(P?.self).nominalDescriptorName - - #expect(t1 == nil) - try #expect(String(cString: #require(t2)) == "T2") - try #expect(String(cString: #require(t3)) == "T3") - #expect(p == nil) - try #expect(String(cString: #require(optionalP)) == "Optional") - } -} - -extension Metadata { - @_silgen_name("OGTypeGetEnumTag") - static func getEnumTag(_ value: V) -> UInt32 -} diff --git a/Tests/OpenGraph_SPICompatibilityTests/Runtime/TupleTypeTests.swift b/Tests/OpenGraph_SPICompatibilityTests/Runtime/TupleTypeTests.swift deleted file mode 100644 index 2f6d1078..00000000 --- a/Tests/OpenGraph_SPICompatibilityTests/Runtime/TupleTypeTests.swift +++ /dev/null @@ -1,63 +0,0 @@ -// -// TupleTypeTests.swift -// OpenGraph_SPICompatibilityTests - -import Testing - -@Suite(.enabled(if: swiftToolchainSupported)) -struct TupleTypeTests { - class T1 { - var a = 0 - var b: Double = 0 - } - - struct T2 { - var a: Int - var b: Double - } - - enum T3 { - case a, b - } - - @Test - func newTupleType() { - let elements: [Metadata] = [Metadata(T1.self), Metadata(T2.self), Metadata(T3.self)] - let tupleType = TupleType(count: 3, elements: elements) - #expect(tupleType.rawValue == Metadata((T1, T2, T3).self).rawValue) - } - - @Test - func tupleCount() { - #expect(TupleType(T1.self).count == 1) - #expect(TupleType([T1.self, T2.self]).count == 2) - #expect(TupleType([T1.self, T2.self, T3.self]).count == 3) - } - - @Test - func tupleSize() { - #expect(TupleType(T1.self).size == 8) - #expect(TupleType([T1.self, T2.self]).size == 24) - #expect(TupleType([T1.self, T2.self, T3.self]).size == 25) - } - - @Test - func tupleElement() { - let tupleType = TupleType([T1.self, T2.self, T3.self]) - #expect(tupleType.elementType(at: 0) == Metadata(T1.self)) - #expect(tupleType.elementType(at: 1) == Metadata(T2.self)) - #expect(tupleType.elementType(at: 2) == Metadata(T3.self)) - - #expect(tupleType.elementSize(at: 0) == 8) - #expect(tupleType.elementSize(at: 1) == 16) - #expect(tupleType.elementSize(at: 2) == 1) - - #expect(tupleType.elementOffset(at: 0) == 0) - #expect(tupleType.elementOffset(at: 1) == 8) - #expect(tupleType.elementOffset(at: 2) == 24) - - #expect(tupleType.elementOffset(at: 0, type: Metadata(T1.self)) == 0) - #expect(tupleType.elementOffset(at: 1, type: Metadata(T2.self)) == 8) - #expect(tupleType.elementOffset(at: 2, type: Metadata(T3.self)) == 24) - } -}