diff --git a/Package.resolved b/Package.resolved
new file mode 100644
index 00000000..a4d4585f
--- /dev/null
+++ b/Package.resolved
@@ -0,0 +1,15 @@
+{
+  "originHash" : "0d1e08a917a619df6510ae568b5ab623f1fc22dffa644b8c590c04c4a5b086bc",
+  "pins" : [
+    {
+      "identity" : "swift-numerics",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/apple/swift-numerics",
+      "state" : {
+        "revision" : "0a5bc04095a675662cf24757cc0640aa2204253b",
+        "version" : "1.0.2"
+      }
+    }
+  ],
+  "version" : 3
+}
diff --git a/Package.swift b/Package.swift
index 6e87d563..59598972 100644
--- a/Package.swift
+++ b/Package.swift
@@ -9,8 +9,14 @@ let package = Package(
         .tvOS(.v12)
     ],
     products: [.library(name: "Stevia", targets: ["Stevia"])],
+    dependencies: [
+        .package(url: "https://github.com/apple/swift-numerics", from: "1.0.2"),
+    ],
     targets: [
         .target(name: "Stevia", path: "Sources", resources: [.copy("PrivacyInfo.xcprivacy")]),
-        .testTarget(name: "SteviaTests", dependencies: ["Stevia"]),
+        .testTarget(name: "SteviaTests", dependencies: [
+            "Stevia",
+            .product(name: "Numerics", package: "swift-numerics"),
+            ]),
     ]
 )
diff --git a/Tests/LinuxMain.swift b/Tests/LinuxMain.swift
deleted file mode 100644
index 65669b23..00000000
--- a/Tests/LinuxMain.swift
+++ /dev/null
@@ -1,7 +0,0 @@
-import XCTest
-
-import SteviaTests
-
-var tests = [XCTestCaseEntry]()
-tests += SteviaTests.allTests()
-XCTMain(tests)
diff --git a/Tests/SteviaTests/BaselineTests.swift b/Tests/SteviaTests/BaselineTests.swift
index 35c5dcf5..c1ef0cf1 100644
--- a/Tests/SteviaTests/BaselineTests.swift
+++ b/Tests/SteviaTests/BaselineTests.swift
@@ -6,43 +6,40 @@
 //  Copyright © 2018 Sacha Durand Saint Omer. All rights reserved.
 //
 
-import XCTest
+import UIKit
 import Stevia
+import Testing
 
-@MainActor class BaselineTests: XCTestCase {
+@Suite
+@MainActor struct BaselineTests {
     
-    var win: UIWindow!
-    var ctrler: UIViewController!
-    var label1 = UILabel()
-    var label2 = UILabel()
+    let win = UIWindow(frame: UIScreen.main.bounds)
+    let ctrler = UIViewController()
+    let label1 = UILabel()
+    let label2 = UILabel()
     
-    override func setUp() async throws {
-        win = UIWindow(frame: UIScreen.main.bounds)
-        ctrler =  UIViewController()
+    init() {
         win.rootViewController = ctrler
-        label1 = UILabel()
-        label2 = UILabel()
-            
         ctrler.view.subviews {
             label1
             label2
         }
     }
     
-    
-    
-    func testAlignLastBaselines() {
+    @Test
+    func alignLastBaselines() {
         label1.top(100)
         align(lastBaselines: label1, label2)
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(label1.forLastBaselineLayout.frame.minY, label2.forLastBaselineLayout.frame.minY)
+        #expect(label1.forLastBaselineLayout.frame.minY == label2.forLastBaselineLayout.frame.minY)
     }
     
-    func testAlignFirstBaselines() {
+    @Test
+    func alignFirstBaselines() {
         label1.top(100)
         align(firstBaselines: label1, label2)
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(label1.forLastBaselineLayout.frame.minY, label2.forLastBaselineLayout.frame.minY)
+        #expect(label1.forLastBaselineLayout.frame.minY == label2.forLastBaselineLayout.frame.minY)
     }
 }
 
diff --git a/Tests/SteviaTests/CenterTests.swift b/Tests/SteviaTests/CenterTests.swift
index e08537af..1b8c4484 100644
--- a/Tests/SteviaTests/CenterTests.swift
+++ b/Tests/SteviaTests/CenterTests.swift
@@ -6,149 +6,137 @@
 //  Copyright © 2016 Sacha Durand Saint Omer. All rights reserved.
 //
 
-import XCTest
+import Testing
+import Numerics
+import UIKit
+import Stevia
 
-let magicalIphoneXShift = 0.17
 
-@MainActor class CenterTests: XCTestCase {
+@Suite
+@MainActor struct CenterTests {
     
-    var win: UIWindow!
-    var ctrler: UIViewController!
-    var v: UIView!
+    let win = UIWindow(frame: UIScreen.main.bounds)
+    var ctrler = UIViewController()
+    var v = UIView()
     
-    override func setUp() async throws {
-//        try await super.setUp()
-        win = UIWindow(frame: UIScreen.main.bounds)
-        ctrler =  UIViewController()
+    init() {
         win.rootViewController = ctrler
-        v = UIView()
-        ctrler.view.subviews { v! }
-        
-        // verify view h as default values
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
-        
+        ctrler.view.subviews { v }
         v.size(100)
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
-    }
-    
-    override func tearDown() {
-        super.tearDown()
     }
     
-    func testCenterHorizontally() {
+    @Test
+    func centerHorizontally() {
         v.centerHorizontally()
         ctrler.view.setNeedsLayout()
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x,
-                                   ctrler.view.frame.width/2.0 - (v.frame.width/2.0),
-                                   accuracy: CGFloat(magicalIphoneXShift))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(isApproximatelyEqual(v.frame.origin.x, ctrler.view.frame.width/2.0 - (v.frame.width/2.0)))
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
-    func testCenterHorizontallyWithOffsetDouble() {
+    @Test
+    func centerHorizontallyWithOffsetDouble() {
         v.centerHorizontally(offset: Double(50))
         ctrler.view.setNeedsLayout()
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x - 50,
-                                   ctrler.view.frame.width/2.0 - (v.frame.width/2.0),
-                                   accuracy: CGFloat(magicalIphoneXShift))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        let val = v.frame.origin.x - 50
+        #expect(isApproximatelyEqual(val, ctrler.view.frame.width/2.0 - (v.frame.width/2.0)))
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
-    func testCenterHorizontallyWithOffsetCGFloat() {
+    @Test
+    func centerHorizontallyWithOffsetCGFloat() {
         v.centerHorizontally(offset: CGFloat(50))
         ctrler.view.setNeedsLayout()
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x - 50,
-                                   ctrler.view.frame.width/2.0 - (v.frame.width/2.0),
-                                   accuracy: CGFloat(magicalIphoneXShift))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        let val = v.frame.origin.x - 50
+        #expect(isApproximatelyEqual(val, (ctrler.view.frame.width/2.0 - (v.frame.width/2.0))))
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
-    func testCenterHorizontallyWithOffsetInt() {
+    @Test
+    func centerHorizontallyWithOffsetInt() {
         v.centerHorizontally(offset: Int(50))
         ctrler.view.setNeedsLayout()
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x - 50,
-                                   ctrler.view.frame.width/2.0 - (v.frame.width/2.0),
-                                   accuracy: CGFloat(magicalIphoneXShift))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        let val = v.frame.origin.x - 50
+        #expect(isApproximatelyEqual(val, (ctrler.view.frame.width/2.0 - (v.frame.width/2.0))))
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
 
-    func testCenterVertically() {
+    @Test
+    func centerVertically() {
         v.centerVertically()
         ctrler.view.setNeedsLayout()
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y,
-                                   ctrler.view.frame.height/2.0 - (v.frame.height/2.0),
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == ctrler.view.frame.height/2.0 - (v.frame.height/2.0))
+        #expect(v.frame.origin.x == 0)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
-    func testCenterVerticallyWithOffsetDouble() {
+    @Test
+    func centerVerticallyWithOffsetDouble() {
         v.centerVertically(offset: Double(50))
         ctrler.view.setNeedsLayout()
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y - 50,
-                                   ctrler.view.frame.height/2.0 - (v.frame.height/2.0),
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        let val = v.frame.origin.y - 50
+        #expect(isApproximatelyEqual(val, (ctrler.view.frame.height/2.0 - (v.frame.height/2.0))))
+        #expect(v.frame.origin.x == 0)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
-    func testCenterVerticallyWithOffsetCGFloat() {
+    @Test
+    func centerVerticallyWithOffsetCGFloat() {
         v.centerVertically(offset: CGFloat(50))
         ctrler.view.setNeedsLayout()
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y - 50,
-                                   ctrler.view.frame.height/2.0 - (v.frame.height/2.0),
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        let val = v.frame.origin.y - 50
+        #expect(isApproximatelyEqual(val, (ctrler.view.frame.height/2.0 - (v.frame.height/2.0))))
+        #expect(v.frame.origin.x == 0)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
-    func testCenterVerticallyWithOffsetInt() {
+    @Test
+    func centerVerticallyWithOffsetInt() {
         v.centerVertically(offset: Int(50))
         ctrler.view.setNeedsLayout()
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y - 50,
-                                   ctrler.view.frame.height/2.0 - (v.frame.height/2.0),
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+
+        let val = v.frame.origin.y - 50
+        #expect(isApproximatelyEqual(val, (ctrler.view.frame.height/2.0 - (v.frame.height/2.0))))
+        #expect(v.frame.origin.x == 0)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
-    func testCenterInContainer() {
+    @Test
+    func centerInContainer() {
         v.centerInContainer()
         ctrler.view.setNeedsLayout()
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y,
-                                   ctrler.view.frame.height/2.0 - (v.frame.height/2.0),
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x,
-                                   ctrler.view.frame.width/2.0 - (v.frame.width/2.0),
-                                   accuracy: CGFloat(magicalIphoneXShift))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        
+        #expect(v.frame.origin.y == ctrler.view.frame.height/2.0 - (v.frame.height/2.0))
+        #expect(isApproximatelyEqual(v.frame.origin.x, ctrler.view.frame.width/2.0 - (v.frame.width/2.0)))
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
+        #expect(isApproximatelyEqual(v.frame.origin.y, ctrler.view.frame.height/2.0 - (v.frame.height/2.0)))
+        #expect(isApproximatelyEqual(v.frame.origin.x, ctrler.view.frame.width/2.0 - (v.frame.width/2.0)))
+        #expect(v.frame.height == 100)
     }
 }
+
+func isApproximatelyEqual(_ a: Double, _ b: Double) -> Bool {
+    return a.isApproximatelyEqual(to: b, absoluteTolerance: 0.5)
+}
diff --git a/Tests/SteviaTests/ContentTests.swift b/Tests/SteviaTests/ContentTests.swift
index aaaebf2b..fcb8036c 100644
--- a/Tests/SteviaTests/ContentTests.swift
+++ b/Tests/SteviaTests/ContentTests.swift
@@ -6,95 +6,72 @@
 //  Copyright © 2016 Sacha Durand Saint Omer. All rights reserved.
 //
 
-import XCTest
-
+import Testing
+import UIKit
 import Stevia
 
 let title = "TitleTest"
 
-@MainActor class UIButtonContentTests: XCTestCase {
+@Suite
+@MainActor struct UIButtonContentTests {
+    
     var button = UIButton()
 
-    override func setUp() async throws {
-//
+    init() {
         button = UIButton()
     }
     
-    override func tearDown() {
-        super.tearDown()
-    }
-
+    @Test
     func testText() {
         button.text(title)
-        XCTAssertEqual(button.currentTitle, title)
-        XCTAssertEqual(button.state, .normal)
+        #expect(button.currentTitle == title)
+        #expect(button.state == .normal)
     }
     
+    @Test
     func testTextKey() {
         button.textKey(title)
-        XCTAssertEqual(button.currentTitle, title)
-    }
-    
-    func testImage() {
-        button.image("foo")
-        //XCTAssertEqual(button.currentImage, title)
+        #expect(button.currentTitle == title)
     }
 }
 
 
-@MainActor class UILabelContentTests: XCTestCase {
-    var label = UILabel()
-    
-    override func setUp() async throws {
-//        super.setUp()
-        label = UILabel()
-    }
+@Suite
+@MainActor struct UILabelContentTests {
     
-    override func tearDown() {
-        super.tearDown()
-    }
+    let label = UILabel()
     
+    @Test
     func testText() {
         label.text(title)
-        XCTAssertEqual(label.text, title)
+        #expect(label.text == title)
     }
     
+    @Test
     func testTextKey() {
         label.textKey(title)
-        XCTAssertEqual(label.text, title)
+        #expect(label.text == title)
     }
 }
 
-@MainActor class UITextFieldContentTests: XCTestCase {
-    var textField = UITextField()
+@Suite
+@MainActor struct UITextFieldContentTests {
     
-    override func setUp() async throws {
-//        super.setUp()
-        textField = UITextField()
-    }
-    
-    override func tearDown() {
-        super.tearDown()
-    }
+    let textField = UITextField()
     
+    @Test
     func testPlaceholder() {
         textField.placeholder(title)
-        XCTAssertEqual(textField.placeholder, title)
+        #expect(textField.placeholder == title)
     }
 }
 
-@MainActor class UIImageViewContentTests: XCTestCase {
-    var imageView = UIImageView()
-    
-    override func setUp() async throws {
-//        super.setUp()
-        imageView = UIImageView()
-    }
-    
-    override func tearDown() {
-        super.tearDown()
-    }
+@Suite
+@MainActor struct UIImageViewContentTests {
     
+    let imageView = UIImageView()
+
+    @Test
     func testImage() {
         imageView.image("foo")
         //XCTAssertEqual(button.currentImage, title)
diff --git a/Tests/SteviaTests/EquationTests.swift b/Tests/SteviaTests/EquationTests.swift
index 5c1eff0d..ecd886a0 100644
--- a/Tests/SteviaTests/EquationTests.swift
+++ b/Tests/SteviaTests/EquationTests.swift
@@ -6,445 +6,493 @@
 //  Copyright © 2017 Sacha Durand Saint Omer. All rights reserved.
 //
 
-import XCTest
+import Testing
+import UIKit
 import Stevia
 
-@MainActor class EquationTests: XCTestCase {
+@Suite
+@MainActor struct EquationTests {
     
-    var win: UIWindow!
-    var ctrler: UIViewController!
+    let win = UIWindow(frame: UIScreen.main.bounds)
+    let ctrler = UIViewController()
     
-    override func setUp() async throws {
-//        super.setUp()
-        win = UIWindow(frame: UIScreen.main.bounds)
-        ctrler =  UIViewController()
+    init() {
         win.rootViewController = ctrler
     }
     
-    override func tearDown() {
-        super.tearDown()
-    }
-    
+    @Test
     func testTopDouble() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Top == ctrler.view.Top + Double(10)
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.y, 10)
+        #expect(v.frame.origin.y == 10)
     }
     
+    @Test
     func testTopCGFloat() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Top == ctrler.view.Top + CGFloat(10)
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.y, 10)
+        #expect(v.frame.origin.y == 10)
     }
     
+    @Test
     func testTopInt() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Top == ctrler.view.Top + Int(10)
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.y, 10)
+        #expect(v.frame.origin.y == 10)
     }
     
+    @Test
     func testTopReflexive() {
         let v = UIView()
         ctrler.view.subviews { v }
         ctrler.view.Top + 10 == v.Top
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.y, 10)
+        #expect(v.frame.origin.y == 10)
     }
     
+    @Test
     func testTopGreaterOrEqual() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Top >= ctrler.view.Top + 10
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.y, 10)
+        #expect(v.frame.origin.y == 10)
     }
     
+    @Test
     func testTopLessThanOrEqual() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Top <= ctrler.view.Top + 10
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.y, 10)
+        #expect(v.frame.origin.y == 10)
     }
     
+    @Test
     func testBottomDouble() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Bottom == ctrler.view.Bottom - Double(23)
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.y, ctrler.view.frame.height - 23)
+        #expect(v.frame.origin.y == ctrler.view.frame.height - 23)
     }
     
+    @Test
     func testBottomCGFloat() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Bottom == ctrler.view.Bottom - CGFloat(23)
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.y, ctrler.view.frame.height - 23)
+        #expect(v.frame.origin.y == ctrler.view.frame.height - 23)
     }
     
+    @Test
     func testBottomInt() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Bottom == ctrler.view.Bottom - Int(23)
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.y, ctrler.view.frame.height - 23)
+        #expect(v.frame.origin.y == ctrler.view.frame.height - 23)
     }
     
+    @Test
     func testBottomReflexive() {
         let v = UIView()
         ctrler.view.subviews { v }
         ctrler.view.Bottom - 23 == v.Bottom
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.y, ctrler.view.frame.height - 23)
+        #expect(v.frame.origin.y == ctrler.view.frame.height - 23)
     }
     
+    @Test
     func testBottomGreaterOrEqual() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Bottom >= ctrler.view.Bottom - 23
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.y, ctrler.view.frame.height - 23)
+        #expect(v.frame.origin.y == ctrler.view.frame.height - 23)
     }
     
+    @Test
     func testBottomLessOrEqual() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Bottom <= ctrler.view.Bottom - 23
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.y, ctrler.view.frame.height - 23)
+        #expect(v.frame.origin.y == ctrler.view.frame.height - 23)
     }
     
+    @Test
     func testLeft() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Left == ctrler.view.Left + 72
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.x, 72)
+        #expect(v.frame.origin.x == 72)
     }
     
+    @Test
     func testLeftReflexive() {
         let v = UIView()
         ctrler.view.subviews { v }
         ctrler.view.Left + 72 == v.Left
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.x, 72)
+        #expect(v.frame.origin.x == 72)
     }
     
+    @Test
     func testLeftGreaterOrEqual() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Left >= ctrler.view.Left + 72
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.x, 72)
+        #expect(v.frame.origin.x == 72)
     }
     
+    @Test
     func testLeftLessOrEqual() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Left <= ctrler.view.Left + 72
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.x, 72)
+        #expect(v.frame.origin.x == 72)
     }
     
+    @Test
     func testRight() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Right == ctrler.view.Right - 13
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.x, ctrler.view.frame.width - 13)
+        #expect(v.frame.origin.x == ctrler.view.frame.width - 13)
     }
     
+    @Test
     func testRightReflexive() {
         let v = UIView()
         ctrler.view.subviews { v }
         ctrler.view.Right - 13 == v.Right
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.x, ctrler.view.frame.width - 13)
+        #expect(v.frame.origin.x == ctrler.view.frame.width - 13)
     }
     
+    @Test
     func testRightGreaterOrEqual() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Right >= ctrler.view.Right - 13
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.x, ctrler.view.frame.width - 13)
+        #expect(v.frame.origin.x == ctrler.view.frame.width - 13)
     }
     
+    @Test
     func testRightLessOrEqual() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Right >= ctrler.view.Right - 13
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.x, ctrler.view.frame.width - 13)
+        #expect(v.frame.origin.x == ctrler.view.frame.width - 13)
     }
     
+    @Test
     func testWidth() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Width == ctrler.view.Width - 52
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.width, ctrler.view.frame.width - 52)
+        #expect(v.frame.width == ctrler.view.frame.width - 52)
     }
     
+    @Test
     func testWidthReflexive() {
         let v = UIView()
         ctrler.view.subviews { v }
         ctrler.view.Width - 52 == v.Width
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.width, ctrler.view.frame.width - 52)
+        #expect(v.frame.width == ctrler.view.frame.width - 52)
     }
     
+    @Test
     func testWidthGreaterOrEqual() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Width >= ctrler.view.Width - 52
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.width, ctrler.view.frame.width - 52)
+        #expect(v.frame.width == ctrler.view.frame.width - 52)
     }
     
+    @Test
     func testWidthLessOrEqual() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Width <= ctrler.view.Width - 52
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.width, 0)
+        #expect(v.frame.width == 0)
     }
     
+    @Test
     func testHeight() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Height == ctrler.view.Height + 34
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.height, ctrler.view.frame.height + 34)
+        #expect(v.frame.height == ctrler.view.frame.height + 34)
     }
     
+    @Test
     func testHeightReflexive() {
         let v = UIView()
         ctrler.view.subviews { v }
         ctrler.view.Height + 34 == v.Height
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.height, ctrler.view.frame.height + 34)
+        #expect(v.frame.height == ctrler.view.frame.height + 34)
     }
     
+    @Test
     func testHeightGreaterOrEqual() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Height >= ctrler.view.Height - 34
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.height, ctrler.view.frame.height - 34)
+        #expect(v.frame.height == ctrler.view.frame.height - 34)
     }
     
+    @Test
     func testHeightLessOrEqual() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Height <= ctrler.view.Height - 34
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.height, 0)
+        #expect(v.frame.height == 0)
     }
 
     // Single Value
     
+    @Test
     func testSingleValueTopDouble() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Top == Double(10)
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.y, 10)
+        #expect(v.frame.origin.y == 10)
     }
     
+    @Test
     func testSingleValueTopCGFloat() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Top == CGFloat(10)
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.y, 10)
+        #expect(v.frame.origin.y == 10)
     }
     
+    @Test
     func testSingleValueTopInt() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Top == Int(10)
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.y, 10)
+        #expect(v.frame.origin.y == 10)
     }
     
+    @Test
     func testSingleValueTopGreaterOrEqualDouble() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Top >= Double(10)
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.y, 10)
+        #expect(v.frame.origin.y == 10)
     }
     
+    @Test
     func testSingleValueTopGreaterOrEqualCGFloat() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Top >= CGFloat(10)
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.y, 10)
+        #expect(v.frame.origin.y == 10)
     }
     
+    @Test
     func testSingleValueTopGreaterOrEqualInt() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Top >= Int(10)
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.y, 10)
+        #expect(v.frame.origin.y == 10)
     }
     
+    @Test
     func testSingleValueLessOrEqualDouble() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Top <= Double(10)
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.y, 10)
+        #expect(v.frame.origin.y == 10)
     }
     
+    @Test
     func testSingleValueLessOrEqualCGFloat() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Top <= CGFloat(10)
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.y, 10)
+        #expect(v.frame.origin.y == 10)
     }
     
+    @Test
     func testSingleValueLessOrEqualInt() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Top <= Int(10)
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.y, 10)
+        #expect(v.frame.origin.y == 10)
     }
     
+    @Test
     func testSingleValueBottom() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Bottom == 23
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.y, ctrler.view.frame.height - 23)
+        #expect(v.frame.origin.y == ctrler.view.frame.height - 23)
     }
     
+    @Test
     func testSingleValueBottomGreaterOrEqual() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Bottom >= 23
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.y, ctrler.view.frame.height - 23)
+        #expect(v.frame.origin.y == ctrler.view.frame.height - 23)
     }
     
+    @Test
     func testSingleValueBottomLessOrEqual() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Bottom <= 23
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.y, ctrler.view.frame.height - 23)
+        #expect(v.frame.origin.y == ctrler.view.frame.height - 23)
     }
     
+    @Test
     func testSingleValueLeft() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Left == 72
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.x, 72)
+        #expect(v.frame.origin.x == 72)
     }
     
+    @Test
     func testSingleValueLeftGreaterOrEqual() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Left >= 72
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.x, 72)
+        #expect(v.frame.origin.x == 72)
     }
     
+    @Test
     func testSingleValueLeftLessOrEqual() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Left <= 72
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.x, 72)
+        #expect(v.frame.origin.x == 72)
     }
     
+    @Test
     func testSingleValueRight() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Right == 13
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.x, ctrler.view.frame.width - 13)
+        #expect(v.frame.origin.x == ctrler.view.frame.width - 13)
     }
     
+    @Test
     func testSingleValueRightGreaterOrEqual() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Right >= 13
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.x, ctrler.view.frame.width - 13)
+        #expect(v.frame.origin.x == ctrler.view.frame.width - 13)
     }
     
+    @Test
     func testSingleValueRightLessOrEqual() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Right <= 13
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.x, ctrler.view.frame.width - 13)
+        #expect(v.frame.origin.x == ctrler.view.frame.width - 13)
     }
     
+    @Test
     func testSingleValueWidth() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Width == 23
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.width, 23)
+        #expect(v.frame.width == 23)
     }
     
+    @Test
     func testSingleValueWidthGreaterOrEqual() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Width >= 23
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.width, 23)
+        #expect(v.frame.width == 23)
     }
     
+    @Test
     func testSingleValueWidthLessOrEqual() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.centerInContainer() // There is a bug where we need to have a x/y placement for size to be accurate.
         v.Width <= 23
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.width, 0)
+        #expect(v.frame.width == 0)
     }
     
+    @Test
     func testSingleValueHeight() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Height == 94
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.height, 94)
+        #expect(v.frame.height == 94)
     }
     
+    @Test
     func testSingleValueHeightGreaterOrEqual() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.Height >= 94
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.height, 94)
+        #expect(v.frame.height == 94)
     }
     
+    @Test
     func testSingleValueHeightLessOrEqual() {
         let v = UIView()
         ctrler.view.subviews { v }
         v.centerInContainer() // There is a bug where we need to have a x/y placement for size to be accurate.
         v.Height <= 94
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.height, 0)
+        #expect(v.frame.height == 0)
     }
     
+    @Test
     func testScrollView() {
         let scrollView = UIScrollView()
         let contentView = UIView()
@@ -456,9 +504,10 @@ import Stevia
         scrollView.fillContainer()
         contentView.Width == ctrler.view.Width
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(contentView.frame.width, ctrler.view.frame.width)
+        #expect(contentView.frame.width == ctrler.view.frame.width)
     }
     
+    @Test
     func testScrollViewReflexive() {
         let scrollView = UIScrollView()
         let contentView = UIView()
@@ -470,9 +519,10 @@ import Stevia
         scrollView.fillContainer()
         ctrler.view.Width == contentView.Width
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(contentView.frame.width, ctrler.view.frame.width)
+        #expect(contentView.frame.width == ctrler.view.frame.width)
     }
     
+    @Test
     func testDifferentViewHierarchies() {
         // Classic example of a field with a dropdown.
         let box = UIView()
@@ -499,9 +549,10 @@ import Stevia
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
         
         let absoluteFieldBottom = field.frame.origin.y + field.frame.height + box.frame.origin.y
-        XCTAssertEqual(absoluteFieldBottom, dropdown.frame.origin.y)
+        #expect(absoluteFieldBottom == dropdown.frame.origin.y)
     }
     
+    @Test
     func testDifferentViewHierarchiesReflexivity() {
         // Classic example of a field with a dropdown.
         let box = UIView()
@@ -527,6 +578,6 @@ import Stevia
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
         
         let absoluteFieldBottom = field.frame.origin.y + field.frame.height + box.frame.origin.y
-        XCTAssertEqual(absoluteFieldBottom, dropdown.frame.origin.y)
+        #expect(absoluteFieldBottom == dropdown.frame.origin.y)
     }
 }
diff --git a/Tests/SteviaTests/FillTests.swift b/Tests/SteviaTests/FillTests.swift
index 38311eba..c6084e63 100644
--- a/Tests/SteviaTests/FillTests.swift
+++ b/Tests/SteviaTests/FillTests.swift
@@ -6,136 +6,130 @@
 //  Copyright © 2016 Sacha Durand Saint Omer. All rights reserved.
 //
 
-import XCTest
-
+import Testing
+import UIKit
 import Stevia
 
-@MainActor class FillTests: XCTestCase {
-    var win: UIWindow!
-    var ctrler: UIViewController!
+@Suite
+@MainActor class FillTests {
+    
+    let win = UIWindow(frame: UIScreen.main.bounds)
+    let ctrler = UIViewController()
 
-    override func setUp() async throws {
-//        super.setUp()
-        win = UIWindow(frame: UIScreen.main.bounds)
-        ctrler =  UIViewController()
+    init() {
         win.rootViewController = ctrler
     }
     
-    override func tearDown() {
-        super.tearDown()
-    }
-
+    @Test
     func testFillContainer() {
         let b = UIButton()
         ctrler.view.subviews { b }
         b.fillContainer()
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(ctrler.view.frame, b.frame)
+        #expect(ctrler.view.frame == b.frame)
     }
     
+    @Test
     func testFillContainerWithPaddingDouble() {
         let padding: Double = 10.0
         let b = UIButton()
         ctrler.view.subviews { b }
         b.fillContainer(padding: padding)
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(ctrler.view.frame.height, b.frame.height + CGFloat(padding) * 2,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(ctrler.view.frame.width, b.frame.width + CGFloat(padding) * 2,
-                                   accuracy: CGFloat(Float.ulpOfOne))
+        #expect(ctrler.view.frame.height == b.frame.height + CGFloat(padding) * 2)
+        #expect(ctrler.view.frame.width == b.frame.width + CGFloat(padding) * 2)
     }
     
+    @Test
     func testFillContainerWithPaddingCGFloat() {
         let padding: CGFloat = 10.0
         let b = UIButton()
         ctrler.view.subviews { b }
         b.fillContainer(padding: padding)
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(ctrler.view.frame.height, b.frame.height + CGFloat(padding) * 2,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(ctrler.view.frame.width, b.frame.width + CGFloat(padding) * 2,
-                                   accuracy: CGFloat(Float.ulpOfOne))
+        #expect(ctrler.view.frame.height == b.frame.height + CGFloat(padding) * 2)
+        #expect(ctrler.view.frame.width == b.frame.width + CGFloat(padding) * 2)
     }
     
+    @Test
     func testFillContainerWithPaddingInt() {
         let padding: Int = 10
         let b = UIButton()
         ctrler.view.subviews { b }
         b.fillContainer(padding: padding)
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(ctrler.view.frame.height, b.frame.height + CGFloat(padding) * 2,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(ctrler.view.frame.width, b.frame.width + CGFloat(padding) * 2,
-                                   accuracy: CGFloat(Float.ulpOfOne))
+        #expect(ctrler.view.frame.height == b.frame.height + CGFloat(padding) * 2)
+        #expect(ctrler.view.frame.width == b.frame.width + CGFloat(padding) * 2)
     }
     
+    @Test
     func testFillVertically() {
         let b = UIButton()
         ctrler.view.subviews { b }
         b.width(10)
         b.fillVertically()
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(ctrler.view.frame.height, b.frame.height)
-        XCTAssertEqual(10, b.frame.width)
+        #expect(ctrler.view.frame.height == b.frame.height)
+        #expect(10 == b.frame.width)
     }
     
+    @Test
     func testFillVerticallyWithPaddingDouble() {
         let padding: Double = 40.0
         let b = UIButton()
         ctrler.view.subviews { b }
         b.fillVertically(padding: padding)
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(ctrler.view.frame.height, b.frame.height + CGFloat(padding) * 2,
-                                   accuracy: CGFloat(Float.ulpOfOne))
+        #expect(ctrler.view.frame.height == b.frame.height + CGFloat(padding) * 2)
     }
     
+    @Test
     func testFillVerticallyWithPaddingCGFloat() {
         let padding: CGFloat = 30.0
         let b = UIButton()
         ctrler.view.subviews { b }
         b.fillVertically(padding: padding)
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(ctrler.view.frame.height, b.frame.height + CGFloat(padding) * 2,
-                                   accuracy: CGFloat(Float.ulpOfOne))
+        #expect(ctrler.view.frame.height == b.frame.height + CGFloat(padding) * 2)
     }
     
+    @Test
     func testFillVerticallyWithPaddingInt() {
         let padding: Int = 14
         let b = UIButton()
         ctrler.view.subviews { b }
         b.fillVertically(padding: padding)
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(ctrler.view.frame.height, b.frame.height + CGFloat(padding) * 2,
-                                   accuracy: CGFloat(Float.ulpOfOne))
+        #expect(ctrler.view.frame.height == b.frame.height + CGFloat(padding) * 2)
     }
     
+    @Test
     func testFillHorizontallyWithPaddingDouble() {
         let padding: Double = 40.0
         let b = UIButton()
         ctrler.view.subviews { b }
         b.fillHorizontally(padding: padding)
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(ctrler.view.frame.width, b.frame.width + CGFloat(padding) * 2,
-                                   accuracy: CGFloat(Float.ulpOfOne))
+        #expect(ctrler.view.frame.width == b.frame.width + CGFloat(padding) * 2)
     }
     
+    @Test
     func testFillHorizontallyWithPaddingCGFloat() {
         let padding: CGFloat = 30.0
         let b = UIButton()
         ctrler.view.subviews { b }
         b.fillHorizontally(padding: padding)
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(ctrler.view.frame.width, b.frame.width + CGFloat(padding) * 2,
-                                   accuracy: CGFloat(Float.ulpOfOne))
+        #expect(ctrler.view.frame.width == b.frame.width + CGFloat(padding) * 2)
     }
     
+    @Test
     func testFillHorizontallyWithPaddingInt() {
         let padding: Int = 14
         let b = UIButton()
         ctrler.view.subviews { b }
         b.fillHorizontally(padding: padding)
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(ctrler.view.frame.width, b.frame.width + CGFloat(padding) * 2,
-                                   accuracy: CGFloat(Float.ulpOfOne))
+        #expect(ctrler.view.frame.width == b.frame.width + CGFloat(padding) * 2)
     }
 }
diff --git a/Tests/SteviaTests/FlexibleMarginTests.swift b/Tests/SteviaTests/FlexibleMarginTests.swift
index 246a67bd..e8ccae50 100644
--- a/Tests/SteviaTests/FlexibleMarginTests.swift
+++ b/Tests/SteviaTests/FlexibleMarginTests.swift
@@ -6,287 +6,296 @@
 //  Copyright © 2016 Sacha Durand Saint Omer. All rights reserved.
 //
 
-import XCTest
+import Testing
+import UIKit
 import Stevia
 
-@MainActor class FlexibleMarginTests: XCTestCase {
+@Suite
+@MainActor struct FlexibleMarginTests {
         
-    var win: UIWindow!
-    var ctrler: UIViewController!
-    var v: UIView!
+    let win = UIWindow(frame: UIScreen.main.bounds)
+    let ctrler = UIViewController()
+    let v = UIView()
     
-    override func setUp() async throws {
-//        super.setUp()
-        win = UIWindow(frame: UIScreen.main.bounds)
-        ctrler =  UIViewController()
+    init() {
         win.rootViewController = ctrler
-        v = UIView()
-        ctrler.view.subviews { v! }
+        ctrler.view.subviews { v }
         v.size(100.0)
     }
     
-    override func tearDown() {
-        super.tearDown()
-    }
-    
-    /// Todo stress test by pushing views
-    
+    @Test
     func testGreaterTopDouble() {
         v.top(>=Double(23))
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 23, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 23)
+        #expect(v.frame.origin.x == 0)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testGreaterTopCGFloat() {
         v.top(>=CGFloat(23))
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 23, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 23)
+        #expect(v.frame.origin.x == 0)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testGreaterTopInt() {
         v.top(>=Int(23))
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 23, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 23)
+        #expect(v.frame.origin.x == 0)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testGreaterBottom() {
         v.bottom(>=45)
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, ctrler.view.frame.height - v.frame.height - 45,
-                        accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == ctrler.view.frame.height - v.frame.height - 45)
+        #expect(v.frame.origin.x == 0)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testGreaterLeft() {
         v.left(>=23)
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 23, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == 23)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testGreaterLeading() {
         v.leading(>=23)
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 23, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == 23)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testGreaterLeadingRTL() {
         ctrler.view.semanticContentAttribute = .forceRightToLeft
         v.leading(>=23)
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, ctrler.view.frame.width - v.frame.width - 23, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == ctrler.view.frame.width - v.frame.width - 23)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
 
+    @Test
     func testGreaterRight() {
         v.right(>=74)
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, ctrler.view.frame.width - v.frame.width - 74,
-                       accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == ctrler.view.frame.width - v.frame.width - 74)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testGreaterTrailing() {
         v.trailing(>=74)
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, ctrler.view.frame.width - v.frame.width - 74,
-                       accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == ctrler.view.frame.width - v.frame.width - 74)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testGreaterTrailingRTL() {
         ctrler.view.semanticContentAttribute = .forceRightToLeft
         v.trailing(>=74)
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 74, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == 74)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testLessTopDouble() {
         v.top(<=Double(23))
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 23, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 23)
+        #expect(v.frame.origin.x == 0)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testLessTopCGFloat() {
         v.top(<=CGFloat(23))
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 23, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 23)
+        #expect(v.frame.origin.x == 0)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testLessTopInt() {
         v.top(<=Int(23))
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 23, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 23)
+        #expect(v.frame.origin.x == 0)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testLessBottom() {
         v.bottom(<=45)
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y,
-                                   ctrler.view.frame.height - v.frame.height - 45,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == ctrler.view.frame.height - v.frame.height - 45)
+        #expect(v.frame.origin.x == 0)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testLessLeft() {
         v.left(<=23)
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 23, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == 23)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testLessLeading() {
         v.leading(<=23)
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 23, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == 23)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testLessLeadingRTL() {
         ctrler.view.semanticContentAttribute = .forceRightToLeft
         v.leading(<=23)
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, ctrler.view.frame.width - v.frame.width - 23,
-                       accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == ctrler.view.frame.width - v.frame.width - 23)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testLessLeftOperator() {
         |-(<=23)-v
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 23, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == 23)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testLessLeftOperatorRTL() {
         ctrler.view.semanticContentAttribute = .forceRightToLeft
         |-(<=23)-v
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, ctrler.view.frame.width - v.frame.width - 23, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == ctrler.view.frame.width - v.frame.width - 23)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testLessRight() {
         v.right(<=74)
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, ctrler.view.frame.width - v.frame.width - 74,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == ctrler.view.frame.width - v.frame.width - 74)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testLessTrailing() {
         v.trailing(<=74)
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, ctrler.view.frame.width - v.frame.width - 74,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == ctrler.view.frame.width - v.frame.width - 74)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
 
+    @Test
     func testLessTrailingRTL() {
         ctrler.view.semanticContentAttribute = .forceRightToLeft
         v.trailing(<=74)
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 74, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == 74)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testLessRightOperator() {
         v-(<=74)-|
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, ctrler.view.frame.width - v.frame.width - 74,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == ctrler.view.frame.width - v.frame.width - 74)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testLessRightOperatorRTL() {
         ctrler.view.semanticContentAttribute = .forceRightToLeft
         v-(<=74)-|
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 74, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == 74)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testMarginGreaterBetweenTwoViews() {
         let v1 = UIView()
         let v2 = UIView()
         v.removeFromSuperview()
         ctrler.view.subviews { v1; v2 }
         for view in ctrler.view.subviews {
-            XCTAssertEqual(view.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+            #expect(view.frame.origin.y == 0)
+            #expect(view.frame.origin.x == 0)
+            #expect(view.frame.width == 0)
+            #expect(view.frame.height == 0)
         }
         
         |v1.width(10)-(>=25)-v2
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v1.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.width, 10, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v1.frame.origin.y == 0)
+        #expect(v1.frame.origin.x == 0)
+        #expect(v1.frame.width == 10)
+        #expect(v1.frame.height == 0)
         
-        XCTAssertEqual(v2.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.origin.x, 35, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v2.frame.origin.y == 0)
+        #expect(v2.frame.origin.x == 35)
+        #expect(v2.frame.width == 0)
+        #expect(v2.frame.height == 0)
     }
     
+    @Test
     func testMarginGreaterBetweenTwoViewsRTL() {
         ctrler.view.semanticContentAttribute = .forceRightToLeft
         let v1 = UIView()
@@ -297,26 +306,27 @@ import Stevia
             v2
         }
         for view in ctrler.view.subviews {
-            XCTAssertEqual(view.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+            #expect(view.frame.origin.y == 0)
+            #expect(view.frame.origin.x == 0)
+            #expect(view.frame.width == 0)
+            #expect(view.frame.height == 0)
         }
         
         |v1.width(10)-(>=25)-v2
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v1.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.origin.x, ctrler.view.frame.width - 10, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.width, 10, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v1.frame.origin.y == 0)
+        #expect(v1.frame.origin.x == ctrler.view.frame.width - 10)
+        #expect(v1.frame.width == 10)
+        #expect(v1.frame.height == 0)
         
-        XCTAssertEqual(v2.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.origin.x, ctrler.view.frame.width - v1.frame.width - 25, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v2.frame.origin.y == 0)
+        #expect(v2.frame.origin.x == ctrler.view.frame.width - v1.frame.width - 25)
+        #expect(v2.frame.width == 0)
+        #expect(v2.frame.height == 0)
         
     }
     
+    @Test
     func testMarginLesserBetweenTwoViews() {
         let v1 = UIView()
         let v2 = UIView()
@@ -326,25 +336,26 @@ import Stevia
             v2
         }
         for view in ctrler.view.subviews {
-            XCTAssertEqual(view.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+            #expect(view.frame.origin.y == 0)
+            #expect(view.frame.origin.x == 0)
+            #expect(view.frame.width == 0)
+            #expect(view.frame.height == 0)
         }
         
         |v1.width(10)-(<=25)-v2
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v1.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.width, 10, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v1.frame.origin.y == 0)
+        #expect(v1.frame.origin.x == 0)
+        #expect(v1.frame.width == 10)
+        #expect(v1.frame.height == 0)
         
-        XCTAssertEqual(v2.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.origin.x, 35, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v2.frame.origin.y == 0)
+        #expect(v2.frame.origin.x == 35)
+        #expect(v2.frame.width == 0)
+        #expect(v2.frame.height == 0)
     }
     
+    @Test
     func testMarginLesserBetweenTwoViewsRTL() {
         ctrler.view.semanticContentAttribute = .forceRightToLeft
         let v1 = UIView()
@@ -355,24 +366,22 @@ import Stevia
             v2
         }
         for view in ctrler.view.subviews {
-            XCTAssertEqual(view.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+            #expect(view.frame.origin.y == 0)
+            #expect(view.frame.origin.x == 0)
+            #expect(view.frame.width == 0)
+            #expect(view.frame.height == 0)
         }
         
         |v1.width(10)-(<=25)-v2
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v1.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.origin.x, ctrler.view.frame.width - 10, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.width, 10, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v1.frame.origin.y == 0)
+        #expect(v1.frame.origin.x == ctrler.view.frame.width - 10)
+        #expect(v1.frame.width == 10)
+        #expect(v1.frame.height == 0)
         
-        XCTAssertEqual(v2.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.origin.x, ctrler.view.frame.width - v1.frame.width - 25,
-                       accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v2.frame.origin.y == 0)
+        #expect(v2.frame.origin.x == ctrler.view.frame.width - v1.frame.width - 25)
+        #expect(v2.frame.width == 0)
+        #expect(v2.frame.height == 0)
     }
-    
 }
diff --git a/Tests/SteviaTests/FullLayoutTests.swift b/Tests/SteviaTests/FullLayoutTests.swift
index 006e01dd..5849a4b6 100644
--- a/Tests/SteviaTests/FullLayoutTests.swift
+++ b/Tests/SteviaTests/FullLayoutTests.swift
@@ -6,7 +6,8 @@
 //  Copyright © 2016 Sacha Durand Saint Omer. All rights reserved.
 //
 
-import XCTest
+import Testing
+import UIKit
 import Stevia
 
 class TestView: UIView {
@@ -53,113 +54,89 @@ class TestView: UIView {
     }
 }
 
-@MainActor class FullLayoutTests: XCTestCase {
+@Suite
+@MainActor class FullLayoutTests {
         
-    var win: UIWindow!
-    var vc: UIViewController!
-    var v: TestView!
+    let win = UIWindow(frame: UIScreen.main.bounds)
+    let vc = UIViewController()
+    let v = TestView()
     
-    override func setUp() async throws  {
-//        super.setUp()
-        win = UIWindow(frame: UIScreen.main.bounds)
-        vc = UIViewController()///TestVC()
+    init() {
         win.rootViewController = vc
-        v = TestView()
         v.frame = vc.view.frame
         vc.view = v
     }
     
-    override func tearDown() {
-        super.tearDown()
-    }
-    
+    @Test
     func testFullLayout() {
-        XCTAssertEqual(vc.view.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(vc.view.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(vc.view.frame.width, win.frame.width,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(vc.view.frame.height, win.frame.height,
-                                   accuracy: CGFloat(Float.ulpOfOne))
+        #expect(vc.view.frame.origin.x == 0)
+        #expect(vc.view.frame.origin.y == 0)
+        #expect(vc.view.frame.width == win.frame.width)
+        #expect(vc.view.frame.height == win.frame.height)
         
         v.layoutIfNeeded()
 
         // Email
-        XCTAssertEqual(v.email.frame.origin.y, 100.5, accuracy: 0.5)
-        XCTAssertEqual(v.email.frame.origin.x, 8, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.email.frame.width, win.frame.width - 8 - 22,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.email.frame.height, win.frame.height*0.1, accuracy: 0.5)
+        #expect(isApproximatelyEqual(v.email.frame.origin.y, 100.5))
+        #expect(v.email.frame.origin.x == 8)
+        #expect(v.email.frame.width == win.frame.width - 8 - 22)
+        #expect(isApproximatelyEqual(v.email.frame.height, win.frame.height*0.1))
         
         // Password
-        XCTAssertEqual(v.password.frame.origin.y,
-                                   v.email.frame.origin.y+v.email.frame.height + 20,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.password.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.password.frame.width, 54, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.password.frame.height, 47, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(isApproximatelyEqual(v.password.frame.origin.y, v.email.frame.origin.y+v.email.frame.height + 20))
+        #expect(v.password.frame.origin.x == 0)
+        #expect(v.password.frame.width == 54)
+        #expect(v.password.frame.height == 47)
         
         // Password
-        XCTAssertEqual(v.login.frame.origin.y,
-                                   win.frame.height - v.login.frame.height - 7,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.login.frame.origin.x,
-                                   win.frame.width/2.0 - (v.login.frame.width/2.0),
-                                   accuracy: CGFloat(magicalIphoneXShift))
-        XCTAssertEqual(v.login.frame.height, 99, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.login.frame.origin.y == win.frame.height - v.login.frame.height - 7)
+        #expect(isApproximatelyEqual(v.login.frame.origin.x, win.frame.width/2.0 - (v.login.frame.width/2.0)))
+        #expect(v.login.frame.height == 99)
     }
     
+    @Test
     func testFullLayoutRTL() {
         vc.view.semanticContentAttribute = .forceRightToLeft
-        XCTAssertEqual(vc.view.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(vc.view.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(vc.view.frame.width, win.frame.width,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(vc.view.frame.height, win.frame.height,
-                                   accuracy: CGFloat(Float.ulpOfOne))
+        #expect(vc.view.frame.origin.x == 0)
+        #expect(vc.view.frame.origin.y == 0)
+        #expect(vc.view.frame.width == win.frame.width)
+        #expect(vc.view.frame.height == win.frame.height)
         
         v.layoutIfNeeded()
 
         // Email
-        XCTAssertEqual(v.email.frame.origin.y, 100.5, accuracy: 0.5)
-        XCTAssertEqual(v.email.frame.origin.x, 22, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.email.frame.width, win.frame.width - 8 - 22,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.email.frame.height, win.frame.height*0.1, accuracy: 0.5)
-        
+        #expect(isApproximatelyEqual(v.email.frame.origin.y, 100.5))
+        #expect(v.email.frame.origin.x == 22)
+        #expect(v.email.frame.width == win.frame.width - 8 - 22)
+        #expect(isApproximatelyEqual(v.email.frame.height, win.frame.height*0.1))
+
         // Password
-        XCTAssertEqual(v.password.frame.origin.y,
-                                   v.email.frame.origin.y+v.email.frame.height + 20,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.password.frame.origin.x, vc.view.frame.width - 54, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.password.frame.width, 54, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.password.frame.height, 47, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(isApproximatelyEqual(v.password.frame.origin.y, v.email.frame.origin.y+v.email.frame.height + 20))
+        #expect(v.password.frame.origin.x == vc.view.frame.width - 54)
+        #expect(v.password.frame.width == 54)
+        #expect(v.password.frame.height == 47)
         
         // Password
-        XCTAssertEqual(v.login.frame.origin.y,
-                                   win.frame.height - v.login.frame.height - 7,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.login.frame.origin.x,
-                                   win.frame.width/2.0 - (v.login.frame.width/2.0),
-                                   accuracy: CGFloat(magicalIphoneXShift))
-        XCTAssertEqual(v.login.frame.height, 99, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.login.frame.origin.y == win.frame.height - v.login.frame.height - 7)
+        #expect(isApproximatelyEqual(v.login.frame.origin.x, win.frame.width/2.0 - (v.login.frame.width/2.0)))
+        #expect(v.login.frame.height == 99)
     }
-    
+
+    @Test
     func testPercentLayout() {
-        XCTAssertEqual(vc.view.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(vc.view.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(vc.view.frame.width, win.frame.width,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(vc.view.frame.height, win.frame.height,
-                                   accuracy: CGFloat(Float.ulpOfOne))
+        #expect(vc.view.frame.origin.x == 0)
+        #expect(vc.view.frame.origin.y == 0)
+        #expect(vc.view.frame.width == win.frame.width)
+        #expect(vc.view.frame.height == win.frame.height)
         
         v.layoutIfNeeded()
         
-        XCTAssertEqual(v.view1.frame.origin.y, v.frame.height*0.1, accuracy: 0.5)
-        XCTAssertEqual(v.view1.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.view1.frame.width, v.frame.width, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.view2.frame.origin.y, (v.frame.height*0.1) + 20 + (v.frame.height*0.33), accuracy: 0.5)
-        XCTAssertEqual(v.view2.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.view2.frame.origin.y + v.view2.frame.height, (v.frame.height*0.8), accuracy: 0.5)
-        XCTAssertEqual(v.view2.frame.width, v.frame.width, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(isApproximatelyEqual(v.view1.frame.origin.y, v.frame.height*0.1))
+        #expect(v.view1.frame.origin.x == 0)
+        #expect(v.view1.frame.width == v.frame.width)
+        #expect(isApproximatelyEqual(v.view2.frame.origin.y, (v.frame.height*0.1) + 20 + (v.frame.height*0.33)))
+        #expect(v.view2.frame.origin.x == 0)
+        #expect(isApproximatelyEqual(v.view2.frame.origin.y + v.view2.frame.height, (v.frame.height*0.8)))
+        #expect(v.view2.frame.width == v.frame.width)
     }
 }
diff --git a/Tests/SteviaTests/GetConstraintsTests.swift b/Tests/SteviaTests/GetConstraintsTests.swift
index 8b594103..6ff5c680 100644
--- a/Tests/SteviaTests/GetConstraintsTests.swift
+++ b/Tests/SteviaTests/GetConstraintsTests.swift
@@ -6,178 +6,177 @@
 //  Copyright © 2017 Sacha Durand Saint Omer. All rights reserved.
 //
 
-import XCTest
+import Testing
+import UIKit
 import Stevia
 
-@MainActor class GetConstraintsTests: XCTestCase {
+@Suite
+@MainActor struct GetConstraintsTests {
     
-    var v: UIView!
-    var spv: UIView!
+    let v = UIView()
+    let spv = UIView()
     
-    override func setUp() async throws {
-        spv = await UIView()
-        v = await UIView()
-        spv.subviews { v! }
+    init() {
+        spv.subviews { v }
     }
     
-    func testCanGetLeftConstraint() {
-        XCTAssertNil(v.leftConstraint)
+    @Test
+    func canGetLeftConstraint() throws {
+        #expect(v.leftConstraint == nil)
         v.left(10)
-        let c = v.leftConstraint
-        XCTAssertNotNil(c)
-        XCTAssertEqual(c?.constant, 10)
-        XCTAssertEqual(c?.firstItem as? UIView, v)
-        XCTAssertEqual(c?.secondItem as? UIView, spv)
-        XCTAssertEqual(c?.firstAttribute, .left)
-        XCTAssertEqual(c?.secondAttribute, .left)
-        XCTAssertEqual(c?.multiplier, 1)
-        XCTAssertEqual(c?.relation, .equal)
-        XCTAssertEqual(c?.priority.rawValue, 751)
-        XCTAssertEqual(c?.isActive, true)
+        let c = try #require(v.leftConstraint)
+        #expect(c.constant == 10)
+        #expect(c.firstItem as? UIView == v)
+        #expect(c.secondItem as? UIView == spv)
+        #expect(c.firstAttribute == .left)
+        #expect(c.secondAttribute == .left)
+        #expect(c.multiplier == 1)
+        #expect(c.relation == .equal)
+        #expect(c.priority.rawValue == 751)
+        #expect(c.isActive)
     }
     
-    func testCanGetRightConstraint() {
-        XCTAssertNil(v.rightConstraint)
+    @Test
+    func canGetRightConstraint() throws {
+        #expect(v.rightConstraint == nil)
         v.right(42)
-        let c = v.rightConstraint
-        XCTAssertNotNil(c)
-        XCTAssertEqual(c?.constant, -42)
-        XCTAssertEqual(c?.firstItem as? UIView, v)
-        XCTAssertEqual(c?.secondItem as? UIView, spv)
-        XCTAssertEqual(c?.firstAttribute, .right)
-        XCTAssertEqual(c?.secondAttribute, .right)
-        XCTAssertEqual(c?.multiplier, 1)
-        XCTAssertEqual(c?.relation, .equal)
-        XCTAssertEqual(c?.priority.rawValue, 751)
-        XCTAssertEqual(c?.isActive, true)
+        let c = try #require(v.rightConstraint)
+        #expect(c.constant == -42)
+        #expect(c.firstItem as? UIView == v)
+        #expect(c.secondItem as? UIView == spv)
+        #expect(c.firstAttribute == .right)
+        #expect(c.secondAttribute == .right)
+        #expect(c.multiplier == 1)
+        #expect(c.relation == .equal)
+        #expect(c.priority.rawValue == 751)
+        #expect(c.isActive)
     }
     
-    func testCanGetTopConstraint() {
-        XCTAssertNil(v.topConstraint)
+    @Test
+    func canGetTopConstraint() throws {
+        #expect(v.topConstraint == nil)
         v.top(23)
-        let c = v.topConstraint
-        XCTAssertNotNil(c)
-        XCTAssertEqual(c?.constant, 23)
-        XCTAssertEqual(c?.firstItem as? UIView, v)
-        XCTAssertEqual(c?.secondItem as? UIView, spv)
-        XCTAssertEqual(c?.firstAttribute, .top)
-        XCTAssertEqual(c?.secondAttribute, .top)
-        XCTAssertEqual(c?.multiplier, 1)
-        XCTAssertEqual(c?.relation, .equal)
-        XCTAssertEqual(c?.priority.rawValue, 751)
-        XCTAssertEqual(c?.isActive, true)
+        let c = try #require(v.topConstraint)
+        #expect(c.constant == 23)
+        #expect(c.firstItem as? UIView == v)
+        #expect(c.secondItem as? UIView == spv)
+        #expect(c.firstAttribute == .top)
+        #expect(c.secondAttribute == .top)
+        #expect(c.multiplier == 1)
+        #expect(c.relation == .equal)
+        #expect(c.priority.rawValue == 751)
+        #expect(c.isActive)
     }
     
-    @MainActor func testCanGetBottomConstraint() {
-        XCTAssertNil(v.bottomConstraint)
+    @Test
+    func testCanGetBottomConstraint() throws {
+        #expect(v.bottomConstraint == nil)
         v.bottom(145)
-        let c = v.bottomConstraint
-        XCTAssertNotNil(c)
-        XCTAssertEqual(c?.constant, -145)
-        XCTAssertEqual(c?.firstItem as? UIView, v)
-        XCTAssertEqual(c?.secondItem as? UIView, spv)
-        XCTAssertEqual(c?.firstAttribute, .bottom)
-        XCTAssertEqual(c?.secondAttribute, .bottom)
-        XCTAssertEqual(c?.multiplier, 1)
-        XCTAssertEqual(c?.relation, .equal)
-        XCTAssertEqual(c?.priority.rawValue, 751)
-        XCTAssertEqual(c?.isActive, true)
+        let c = try #require(v.bottomConstraint)
+        #expect(c.constant == -145)
+        #expect(c.firstItem as? UIView == v)
+        #expect(c.secondItem as? UIView == spv)
+        #expect(c.firstAttribute == .bottom)
+        #expect(c.secondAttribute == .bottom)
+        #expect(c.multiplier == 1)
+        #expect(c.relation == .equal)
+        #expect(c.priority.rawValue == 751)
+        #expect(c.isActive)
     }
     
-    @MainActor func testCanGetHeightConstraint() {
-        XCTAssertNil(v.heightConstraint)
+    @Test
+    func testCanGetHeightConstraint() throws {
+        #expect(v.heightConstraint == nil)
         v.height(35)
-        let c = v.heightConstraint
-        XCTAssertNotNil(c)
-        XCTAssertEqual(c?.constant, 35)
-        XCTAssertEqual(c?.firstItem as? UIView, v)
-        XCTAssertNil(c?.secondItem)
-        XCTAssertEqual(c?.firstAttribute, .height)
-        XCTAssertEqual(c?.secondAttribute, .notAnAttribute)
-        XCTAssertEqual(c?.multiplier, 1)
-        XCTAssertEqual(c?.relation, .equal)
-        XCTAssertEqual(c?.priority.rawValue, 751)
-        XCTAssertEqual(c?.isActive, true)
+        let c = try #require(v.heightConstraint)
+        #expect(c.constant == 35)
+        #expect(c.firstItem as? UIView == v)
+        #expect(c.secondItem == nil)
+        #expect(c.firstAttribute == .height)
+        #expect(c.secondAttribute == .notAnAttribute)
+        #expect(c.multiplier == 1)
+        #expect(c.relation == .equal)
+        #expect(c.priority.rawValue == 751)
+        #expect(c.isActive)
     }
     
-    @MainActor func testCanGetWidthConstraint() {
-        XCTAssertNil(v.widthConstraint)
+    @Test
+    func canGetWidthConstraint() throws {
+        #expect(v.widthConstraint == nil)
         v.width(51)
-        let c = v.widthConstraint
-        XCTAssertNotNil(c)
-        XCTAssertEqual(c?.constant, 51)
-        XCTAssertEqual(c?.firstItem as? UIView, v)
-        XCTAssertNil(c?.secondItem)
-        XCTAssertEqual(c?.firstAttribute, .width)
-        XCTAssertEqual(c?.secondAttribute, .notAnAttribute)
-        XCTAssertEqual(c?.multiplier, 1)
-        XCTAssertEqual(c?.relation, .equal)
-        XCTAssertEqual(c?.priority.rawValue, 751)
-        XCTAssertEqual(c?.isActive, true)
+        let c = try #require(v.widthConstraint)
+        #expect(c.constant == 51)
+        #expect(c.firstItem as? UIView == v)
+        #expect(c.secondItem == nil)
+        #expect(c.firstAttribute == .width)
+        #expect(c.secondAttribute == .notAnAttribute)
+        #expect(c.multiplier == 1)
+        #expect(c.relation == .equal)
+        #expect(c.priority.rawValue == 751)
+        #expect(c.isActive)
     }
     
-    @MainActor func testCanGetTrailingConstraint() {
-        XCTAssertNil(v.trailingConstraint)
+    @Test
+    func canGetTrailingConstraint() throws {
+        #expect(v.trailingConstraint == nil)
         v.trailingAnchor.constraint(equalTo: spv.trailingAnchor, constant: 104).isActive = true
-        let c = v.trailingConstraint
-        XCTAssertNotNil(c)
-        XCTAssertEqual(c?.constant, 104)
-        XCTAssertEqual(c?.firstItem as? UIView, v)
-        XCTAssertEqual(c?.secondItem as? UIView, spv)
-        XCTAssertEqual(c?.firstAttribute, .trailing)
-        XCTAssertEqual(c?.secondAttribute, .trailing)
-        XCTAssertEqual(c?.multiplier, 1)
-        XCTAssertEqual(c?.relation, .equal)
-        XCTAssertEqual(c?.priority.rawValue, 1000)
-        XCTAssertEqual(c?.isActive, true)
+        let c = try #require(v.trailingConstraint)
+        #expect(c.constant == 104)
+        #expect(c.firstItem as? UIView == v)
+        #expect(c.secondItem as? UIView == spv)
+        #expect(c.firstAttribute == .trailing)
+        #expect(c.secondAttribute == .trailing)
+        #expect(c.multiplier == 1)
+        #expect(c.relation == .equal)
+        #expect(c.priority.rawValue == 1000)
+        #expect(c.isActive)
     }
     
-    @MainActor func testCanGetLeadingonstraint() {
-        XCTAssertNil(v.leadingConstraint)
+    @Test
+    func canGetLeadingonstraint() throws {
+        #expect(v.leadingConstraint == nil)
         v.leadingAnchor.constraint(equalTo: spv.leadingAnchor, constant: 73).isActive = true
-        let c = v.leadingConstraint
-        XCTAssertNotNil(c)
-        XCTAssertEqual(c?.constant, 73)
-        XCTAssertEqual(c?.firstItem as? UIView, v)
-        XCTAssertEqual(c?.secondItem as? UIView, spv)
-        XCTAssertEqual(c?.firstAttribute, .leading)
-        XCTAssertEqual(c?.secondAttribute, .leading)
-        XCTAssertEqual(c?.multiplier, 1)
-        XCTAssertEqual(c?.relation, .equal)
-        XCTAssertEqual(c?.priority.rawValue, 1000)
-        XCTAssertEqual(c?.isActive, true)
+        let c = try #require(v.leadingConstraint)
+        #expect(c.constant == 73)
+        #expect(c.firstItem as? UIView == v)
+        #expect(c.secondItem as? UIView == spv)
+        #expect(c.firstAttribute == .leading)
+        #expect(c.secondAttribute == .leading)
+        #expect(c.multiplier == 1)
+        #expect(c.relation == .equal)
+        #expect(c.priority.rawValue == 1000)
+        #expect(c.isActive)
     }
     
-    @MainActor func testCanGetCenterXConstraint() {
-        XCTAssertNil(v.centerXConstraint)
+    @Test
+    func canGetCenterXConstraint() throws {
+        #expect(v.centerXConstraint == nil)
         v.CenterX == spv.CenterX + 27
-        let c = v.centerXConstraint
-        XCTAssertNotNil(c)
-        XCTAssertEqual(c?.constant, 27)
-        XCTAssertEqual(c?.firstItem as? UIView, v)
-        XCTAssertEqual(c?.secondItem as? UIView, spv)
-        XCTAssertEqual(c?.firstAttribute, .centerX)
-        XCTAssertEqual(c?.secondAttribute, .centerX)
-        XCTAssertEqual(c?.multiplier, 1)
-        XCTAssertEqual(c?.relation, .equal)
-        XCTAssertEqual(c?.priority.rawValue, 751)
-        XCTAssertEqual(c?.isActive, true)
+        let c = try #require(v.centerXConstraint)
+        #expect(c.constant == 27)
+        #expect(c.firstItem as? UIView == v)
+        #expect(c.secondItem as? UIView == spv)
+        #expect(c.firstAttribute == .centerX)
+        #expect(c.secondAttribute == .centerX)
+        #expect(c.multiplier == 1)
+        #expect(c.relation == .equal)
+        #expect(c.priority.rawValue == 751)
+        #expect(c.isActive)
     }
     
-    @MainActor func testCanGetCenterYConstraint() {
-        XCTAssertNil(v.centerYConstraint)
+    @Test
+    func canGetCenterYConstraint() throws {
+        #expect(v.centerYConstraint == nil)
         v.CenterY == spv.CenterY - 32
-        let c = v.centerYConstraint
-        XCTAssertNotNil(c)
-        XCTAssertEqual(c?.constant, -32)
-        XCTAssertEqual(c?.firstItem as? UIView, v)
-        XCTAssertEqual(c?.secondItem as? UIView, spv)
-        XCTAssertEqual(c?.firstAttribute, .centerY)
-        XCTAssertEqual(c?.secondAttribute, .centerY)
-        XCTAssertEqual(c?.multiplier, 1)
-        XCTAssertEqual(c?.relation, .equal)
-        XCTAssertEqual(c?.priority.rawValue, 751)
-        XCTAssertEqual(c?.isActive, true)
+        let c = try #require(v.centerYConstraint)
+        #expect(c.constant == -32)
+        #expect(c.firstItem as? UIView == v)
+        #expect(c.secondItem as? UIView == spv)
+        #expect(c.firstAttribute == .centerY)
+        #expect(c.secondAttribute == .centerY)
+        #expect(c.multiplier == 1)
+        #expect(c.relation == .equal)
+        #expect(c.priority.rawValue == 751)
+        #expect(c.isActive)
     }
-    
 }
diff --git a/Tests/SteviaTests/HierarchyTests.swift b/Tests/SteviaTests/HierarchyTests.swift
index db0573e8..c8d384a7 100644
--- a/Tests/SteviaTests/HierarchyTests.swift
+++ b/Tests/SteviaTests/HierarchyTests.swift
@@ -6,67 +6,16 @@
 //  Copyright © 2016 Sacha Durand Saint Omer. All rights reserved.
 //
 
-import XCTest
+import Testing
+import UIKit
 import Stevia
 
-@MainActor class HierarchyTests: XCTestCase {
-
-    override func setUp() {
-        super.setUp()
-    }
+@Suite
+@MainActor
+struct HierarchyTests {
     
-    override func tearDown() {
-        super.tearDown()
-    }
-
-    func testLegacySv() {
-        let view = UIView()
-        let v1 = UIView()
-        let v2 = UIView()
-        view.sv(
-            v1,
-            v2
-        )
-        XCTAssertEqual(view.subviews.count, 2)
-        XCTAssertTrue(view.subviews.contains(v1))
-        XCTAssertTrue(view.subviews.contains(v2))
-        XCTAssertFalse(v1.translatesAutoresizingMaskIntoConstraints)
-        XCTAssertFalse(v2.translatesAutoresizingMaskIntoConstraints)
-    }
-
-    func testLegacyTableViewCellSV() {
-        let cell = UITableViewCell()
-        let v1 = UIView()
-        let v2 = UIView()
-        cell.sv(
-            v1,
-            v2
-        )
-        XCTAssertEqual(cell.contentView.subviews.count, 2)
-        XCTAssertTrue(cell.contentView.subviews.contains(v1))
-        XCTAssertTrue(cell.contentView.subviews.contains(v2))
-        XCTAssertFalse(v1.translatesAutoresizingMaskIntoConstraints)
-        XCTAssertFalse(v2.translatesAutoresizingMaskIntoConstraints)
-    }
-    
-    func testLegacyCollectionViewCellSV() {
-        let cell = UICollectionViewCell()
-        let v1 = UIView()
-        let v2 = UIView()
-        cell.sv(
-            v1,
-            v2
-            )
-        XCTAssertEqual(cell.contentView.subviews.count, 2)
-        XCTAssertTrue(cell.contentView.subviews.contains(v1))
-        XCTAssertTrue(cell.contentView.subviews.contains(v2))
-        XCTAssertFalse(v1.translatesAutoresizingMaskIntoConstraints)
-        XCTAssertFalse(v2.translatesAutoresizingMaskIntoConstraints)
-    }
-    
-    // Function Builders version
-    
-    func testSubviews() {
+    @Test
+    func subviews() {
         let view = UIView()
         let v1 = UIView()
         let v2 = UIView()
@@ -74,14 +23,15 @@ import Stevia
             v1
             v2
         }
-        XCTAssertEqual(view.subviews.count, 2)
-        XCTAssertTrue(view.subviews.contains(v1))
-        XCTAssertTrue(view.subviews.contains(v2))
-        XCTAssertFalse(v1.translatesAutoresizingMaskIntoConstraints)
-        XCTAssertFalse(v2.translatesAutoresizingMaskIntoConstraints)
+        #expect(view.subviews.count == 2)
+        #expect(view.subviews.contains(v1))
+        #expect(view.subviews.contains(v2))
+        #expect(v1.translatesAutoresizingMaskIntoConstraints == false)
+        #expect(v2.translatesAutoresizingMaskIntoConstraints == false)
     }
     
-    func testTableViewCellSubviews() {
+    @Test
+    func tableViewCellSubviews() {
         let cell = UITableViewCell()
         let v1 = UIView()
         let v2 = UIView()
@@ -90,14 +40,14 @@ import Stevia
             v2
         }
             
-        
-        XCTAssertEqual(cell.contentView.subviews.count, 2)
-        XCTAssertTrue(cell.contentView.subviews.contains(v1))
-        XCTAssertTrue(cell.contentView.subviews.contains(v2))
-        XCTAssertFalse(v1.translatesAutoresizingMaskIntoConstraints)
-        XCTAssertFalse(v2.translatesAutoresizingMaskIntoConstraints)
+        #expect(cell.contentView.subviews.count ==  2)
+        #expect(cell.contentView.subviews.contains(v1))
+        #expect(cell.contentView.subviews.contains(v2))
+        #expect(v1.translatesAutoresizingMaskIntoConstraints == false)
+        #expect(v2.translatesAutoresizingMaskIntoConstraints == false)
     }
 
+    @Test
     func testCollectionViewCellSubviews() {
         let cell = UICollectionViewCell()
         let v1 = UIView()
@@ -106,13 +56,14 @@ import Stevia
             v1
             v2
         }
-        XCTAssertEqual(cell.contentView.subviews.count, 2)
-        XCTAssertTrue(cell.contentView.subviews.contains(v1))
-        XCTAssertTrue(cell.contentView.subviews.contains(v2))
-        XCTAssertFalse(v1.translatesAutoresizingMaskIntoConstraints)
-        XCTAssertFalse(v2.translatesAutoresizingMaskIntoConstraints)
+        #expect(cell.contentView.subviews.count == 2)
+        #expect(cell.contentView.subviews.contains(v1))
+        #expect(cell.contentView.subviews.contains(v2))
+        #expect(v1.translatesAutoresizingMaskIntoConstraints == false)
+        #expect(v2.translatesAutoresizingMaskIntoConstraints == false)
     }
-    
+   
+    @Test
     func testSubviewsCanBeNested() {
         let view = UIView()
         let v1 = UIView()
@@ -126,16 +77,16 @@ import Stevia
             }
             v2
         }
-        XCTAssertEqual(view.subviews.count, 2)
-        XCTAssertTrue(view.subviews.contains(v1))
-        XCTAssertTrue(view.subviews.contains(v2))
-        XCTAssertEqual(v1.subviews.count, 2)
-        XCTAssertTrue(v1.subviews.contains(v3))
-        XCTAssertTrue(v1.subviews.contains(v4))
+        #expect(view.subviews.count == 2)
+        #expect(view.subviews.contains(v1))
+        #expect(view.subviews.contains(v2))
+        #expect(v1.subviews.count == 2)
+        #expect(v1.subviews.contains(v3))
+        #expect(v1.subviews.contains(v4))
         
-        XCTAssertFalse(v1.translatesAutoresizingMaskIntoConstraints)
-        XCTAssertFalse(v2.translatesAutoresizingMaskIntoConstraints)
-        XCTAssertFalse(v3.translatesAutoresizingMaskIntoConstraints)
-        XCTAssertFalse(v4.translatesAutoresizingMaskIntoConstraints)
+        #expect(v1.translatesAutoresizingMaskIntoConstraints == false)
+        #expect(v2.translatesAutoresizingMaskIntoConstraints == false)
+        #expect(v3.translatesAutoresizingMaskIntoConstraints == false)
+        #expect(v4.translatesAutoresizingMaskIntoConstraints == false)
     }
 }
diff --git a/Tests/SteviaTests/LayoutTests.swift b/Tests/SteviaTests/LayoutTests.swift
index 2a3bf424..f719c162 100644
--- a/Tests/SteviaTests/LayoutTests.swift
+++ b/Tests/SteviaTests/LayoutTests.swift
@@ -6,29 +6,23 @@
 //  Copyright © 2016 Sacha Durand Saint Omer. All rights reserved.
 //
 
-import XCTest
+import Testing
+import UIKit
 import Stevia
 
-@MainActor class LayoutTests: XCTestCase {
+@Suite
+@MainActor class LayoutTests {
     
-    var win: UIWindow!
-    var ctrler: UIViewController!
-    var v: UIView!
+    let win = UIWindow(frame: UIScreen.main.bounds)
+    let ctrler = UIViewController()
+    let v = UIView()
     
-    override func setUp() async throws {
-//        super.setUp()
-        win = UIWindow(frame: UIScreen.main.bounds)
-        ctrler =  UIViewController()
+    init() {
         win.rootViewController = ctrler
-        v = UIView()
-        ctrler.view.subviews { v! }
-        verifyViewHasDefaultValues()
-    }
-    
-    override func tearDown() {
-        super.tearDown()
+        ctrler.view.subviews { v }
     }
     
+    @Test
     func testComplexLayout() {
         let featureA = UIView()
         let featureB = UIView()
@@ -40,218 +34,233 @@ import Stevia
         //align(horizontally: |-6-feature1-2-feature2-6-|)
     }
     
+    @Test
     func testEmptyLeftMargin() {
         |v
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x,  0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == 0)
+        #expect(v.frame.width == 0)
+        #expect(v.frame.height == 0)
     }
     
+    @Test
     func testEmptyLeftMarginRTL() {
         ctrler.view.semanticContentAttribute = .forceRightToLeft
         |v
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, ctrler.view.frame.width, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == ctrler.view.frame.width)
+        #expect(v.frame.width == 0)
+        #expect(v.frame.height == 0)
     }
     
+    @Test
     func testDefaultMargin() {
         |-v
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 8, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == 8)
+        #expect(v.frame.width == 0)
+        #expect(v.frame.height == 0)
     }
     
+    @Test
     func testDefaultMarginRTL() {
         ctrler.view.semanticContentAttribute = .forceRightToLeft
         |-v
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, ctrler.view.frame.width - 8, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == ctrler.view.frame.width - 8)
+        #expect(v.frame.width == 0)
+        #expect(v.frame.height == 0)
     }
     
+    @Test
     func testLeftMarginDouble() {
         |-Double(75)-v
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 75, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == 75)
+        #expect(v.frame.width == 0)
+        #expect(v.frame.height == 0)
     }
     
+    @Test
     func testLeftMarginCGFloat() {
         |-CGFloat(75)-v
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 75, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == 75)
+        #expect(v.frame.width == 0)
+        #expect(v.frame.height == 0)
     }
 
+    @Test
     func testLeftMarginInt() {
         |-Int(75)-v
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 75, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == 75)
+        #expect(v.frame.width == 0)
+        #expect(v.frame.height == 0)
     }
     
+    @Test
     func testLeftMarginRTL() {
         ctrler.view.semanticContentAttribute = .forceRightToLeft
         |-75-v
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, ctrler.view.frame.width - 75, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == ctrler.view.frame.width - 75)
+        #expect(v.frame.width == 0)
+        #expect(v.frame.height == 0)
     }
     
+    @Test
     func testEmptyRightMargin() {
         v|
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, ctrler.view.frame.width - v.frame.width,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == ctrler.view.frame.width - v.frame.width)
+        #expect(v.frame.width == 0)
+        #expect(v.frame.height == 0)
     }
     
+    @Test
     func testEmptyRightMarginRTL() {
         ctrler.view.semanticContentAttribute = .forceRightToLeft
         v|
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 0,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == 0)
+        #expect(v.frame.width == 0)
+        #expect(v.frame.height == 0)
     }
     
+    @Test
     func testDefaultRightMargin() {
         v-|
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, ctrler.view.frame.width - v.frame.width - 8,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == ctrler.view.frame.width - v.frame.width - 8)
+        #expect(v.frame.width == 0)
+        #expect(v.frame.height == 0)
     }
     
+    @Test
     func testDefaultRightMarginRTL() {
         ctrler.view.semanticContentAttribute = .forceRightToLeft
         v-|
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 8,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == 8)
+        #expect(v.frame.width == 0)
+        #expect(v.frame.height == 0)
     }
     
+    @Test
     func testRightMarginDouble() {
         v-Double(14)-|
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, ctrler.view.frame.width - v.frame.width - 14,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == ctrler.view.frame.width - v.frame.width - 14)
+        #expect(v.frame.width == 0)
+        #expect(v.frame.height == 0)
     }
     
+    @Test
     func testRightMarginCGFloat() {
         v-CGFloat(14)-|
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, ctrler.view.frame.width - v.frame.width - 14,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == ctrler.view.frame.width - v.frame.width - 14)
+        #expect(v.frame.width == 0)
+        #expect(v.frame.height == 0)
     }
     
+    @Test
     func testRightMarginInt() {
         v-Int(14)-|
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, ctrler.view.frame.width - v.frame.width - 14,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == ctrler.view.frame.width - v.frame.width - 14)
+        #expect(v.frame.width == 0)
+        #expect(v.frame.height == 0)
     }
     
+    @Test
     func testRightMarginRTL() {
         ctrler.view.semanticContentAttribute = .forceRightToLeft
         v-14-|
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 14,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == 14)
+        #expect(v.frame.width == 0)
+        #expect(v.frame.height == 0)
     }
 
+    @Test
     func testHeightDouble() {
         v ~ Double(180)
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 180, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == 0)
+        #expect(v.frame.width == 0)
+        #expect(v.frame.height == 180)
     }
     
+    @Test
     func testHeightCGFloat() {
         v ~ CGFloat(180)
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 180, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == 0)
+        #expect(v.frame.width == 0)
+        #expect(v.frame.height == 180)
     }
     
+    @Test
     func testHeightInt() {
         v ~ Int(180)
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 180, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == 0)
+        #expect(v.frame.width == 0)
+        #expect(v.frame.height == 180)
     }
     
+    @Test
     func testHeightPercentageDouble() {
         v ~ Double(25)%
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, ctrler.view.frame.height*0.25, accuracy: 0.5)
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == 0)
+        #expect(v.frame.width == 0)
+        #expect(v.frame.height == ctrler.view.frame.height*0.25)
     }
     
+    @Test
     func testHeightPercentageCGFloat() {
         v ~ CGFloat(25)%
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, ctrler.view.frame.height*0.25, accuracy: 0.5)
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == 0)
+        #expect(v.frame.width == 0)
+        #expect(v.frame.height == ctrler.view.frame.height*0.25)
     }
     
+    @Test
     func testHeightPercentageInt() {
         v ~ Int(25)%
         ctrler.view.layoutIfNeeded() // This is needed to force auto-layout to kick-in
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, ctrler.view.frame.height*0.25, accuracy: 0.5)
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == 0)
+        #expect(v.frame.width == 0)
+        #expect(v.frame.height == ctrler.view.frame.height*0.25)
     }
     
+    @Test
     func testMultipleHeightsAtOnceDouble() {
         let v1 = UIView()
         let v2 = UIView()
@@ -263,21 +272,22 @@ import Stevia
             v3
         }
         for view in ctrler.view.subviews {
-            XCTAssertEqual(view.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+            #expect(view.frame.origin.y == 0)
+            #expect(view.frame.origin.x == 0)
+            #expect(view.frame.width == 0)
+            #expect(view.frame.height == 0)
         }
         [v1, v2, v3] ~ Double(63)
         ctrler.view.layoutIfNeeded()
         for view in ctrler.view.subviews {
-            XCTAssertEqual(view.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.height, 63, accuracy: CGFloat(Float.ulpOfOne))
+            #expect(view.frame.origin.y == 0)
+            #expect(view.frame.origin.x == 0)
+            #expect(view.frame.width == 0)
+            #expect(view.frame.height == 63)
         }
     }
     
+    @Test
     func testMultipleHeightsAtOnceCGFloat() {
         let v1 = UIView()
         let v2 = UIView()
@@ -289,21 +299,22 @@ import Stevia
             v3
         }
         for view in ctrler.view.subviews {
-            XCTAssertEqual(view.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+            #expect(view.frame.origin.y == 0)
+            #expect(view.frame.origin.x == 0)
+            #expect(view.frame.width == 0)
+            #expect(view.frame.height == 0)
         }
         [v1, v2, v3] ~ CGFloat(63)
         ctrler.view.layoutIfNeeded()
         for view in ctrler.view.subviews {
-            XCTAssertEqual(view.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.height, 63, accuracy: CGFloat(Float.ulpOfOne))
+            #expect(view.frame.origin.y == 0)
+            #expect(view.frame.origin.x == 0)
+            #expect(view.frame.width == 0)
+            #expect(view.frame.height == 63)
         }
     }
     
+    @Test
     func testMultipleHeightsAtOnceInt() {
         let v1 = UIView()
         let v2 = UIView()
@@ -315,21 +326,22 @@ import Stevia
             v3
         }
         for view in ctrler.view.subviews {
-            XCTAssertEqual(view.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+            #expect(view.frame.origin.y == 0)
+            #expect(view.frame.origin.x == 0)
+            #expect(view.frame.width == 0)
+            #expect(view.frame.height == 0)
         }
         [v1, v2, v3] ~ Int(63)
         ctrler.view.layoutIfNeeded()
         for view in ctrler.view.subviews {
-            XCTAssertEqual(view.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.height, 63, accuracy: CGFloat(Float.ulpOfOne))
+            #expect(view.frame.origin.y == 0)
+            #expect(view.frame.origin.x == 0)
+            #expect(view.frame.width == 0)
+            #expect(view.frame.height == 63)
         }
     }
     
+    @Test
     func testDefaultMarginBetweenTwoViews() {
         let v1 = UIView()
         let v2 = UIView()
@@ -339,25 +351,26 @@ import Stevia
             v2
         }
         for view in ctrler.view.subviews {
-            XCTAssertEqual(view.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+            #expect(view.frame.origin.y == 0)
+            #expect(view.frame.origin.x == 0)
+            #expect(view.frame.width == 0)
+            #expect(view.frame.height == 0)
         }
         
         |v1.width(10)-v2
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v1.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.width, 10, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v1.frame.origin.y == 0)
+        #expect(v1.frame.origin.x == 0)
+        #expect(v1.frame.width == 10)
+        #expect(v1.frame.height == 0)
         
-        XCTAssertEqual(v2.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.origin.x, 18, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v2.frame.origin.y == 0)
+        #expect(v2.frame.origin.x == 18)
+        #expect(v2.frame.width == 0)
+        #expect(v2.frame.height == 0)
     }
     
+    @Test
     func testDefaultMarginBetweenTwoViewsRTL() {
         ctrler.view.semanticContentAttribute = .forceRightToLeft
         let v1 = UIView()
@@ -368,25 +381,26 @@ import Stevia
             v2
         }
         for view in ctrler.view.subviews {
-            XCTAssertEqual(view.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+            #expect(view.frame.origin.y == 0)
+            #expect(view.frame.origin.x == 0)
+            #expect(view.frame.width == 0)
+            #expect(view.frame.height == 0)
         }
         
         |v1.width(10)-v2
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v1.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.origin.x, ctrler.view.frame.width - 10, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.width, 10, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v1.frame.origin.y == 0)
+        #expect(v1.frame.origin.x == ctrler.view.frame.width - 10)
+        #expect(v1.frame.width == 10)
+        #expect(v1.frame.height == 0)
         
-        XCTAssertEqual(v2.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.origin.x, ctrler.view.frame.width - 10 - 8, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v2.frame.origin.y == 0)
+        #expect(v2.frame.origin.x == ctrler.view.frame.width - 10 - 8)
+        #expect(v2.frame.width == 0)
+        #expect(v2.frame.height == 0)
     }
     
+    @Test
     func testMarginBetweenTwoViewsDouble() {
         let v1 = UIView()
         let v2 = UIView()
@@ -396,25 +410,26 @@ import Stevia
             v2
         }
         for view in ctrler.view.subviews {
-            XCTAssertEqual(view.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+            #expect(view.frame.origin.y == 0)
+            #expect(view.frame.origin.x == 0)
+            #expect(view.frame.width == 0)
+            #expect(view.frame.height == 0)
         }
         let m: Double = 52
         |v1.width(10)-m-v2
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v1.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.width, 10, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v1.frame.origin.y == 0)
+        #expect(v1.frame.origin.x == 0)
+        #expect(v1.frame.width == 10)
+        #expect(v1.frame.height == 0)
         
-        XCTAssertEqual(v2.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.origin.x, 62, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v2.frame.origin.y == 0)
+        #expect(v2.frame.origin.x == 62)
+        #expect(v2.frame.width == 0)
+        #expect(v2.frame.height == 0)
     }
     
+    @Test
     func testMarginBetweenTwoViewsCGFloat() {
         let v1 = UIView()
         let v2 = UIView()
@@ -424,24 +439,24 @@ import Stevia
             v2
         }
         for view in ctrler.view.subviews {
-            XCTAssertEqual(view.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+            #expect(view.frame.origin.y == 0)
+            #expect(view.frame.origin.x == 0)
+            #expect(view.frame.width == 0)
+            #expect(view.frame.height == 0)
         }
 
         let m: CGFloat = 52
         |v1.width(10)-m-v2
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v1.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.width, 10, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v1.frame.origin.y == 0)
+        #expect(v1.frame.origin.x == 0)
+        #expect(v1.frame.width == 10)
+        #expect(v1.frame.height == 0)
 
-        XCTAssertEqual(v2.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.origin.x, 62, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v2.frame.origin.y == 0)
+        #expect(v2.frame.origin.x == 62)
+        #expect(v2.frame.width == 0)
+        #expect(v2.frame.height == 0)
     }
     
     func testMarginBetweenTwoViewsInt() {
@@ -453,26 +468,27 @@ import Stevia
             v2
         }
         for view in ctrler.view.subviews {
-            XCTAssertEqual(view.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+            #expect(view.frame.origin.y == 0)
+            #expect(view.frame.origin.x == 0)
+            #expect(view.frame.width == 0)
+            #expect(view.frame.height == 0)
         }
 
         let m: Int = 52
         |v1.width(10)-m-v2
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v1.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.width, 10, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v1.frame.origin.y == 0)
+        #expect(v1.frame.origin.x == 0)
+        #expect(v1.frame.width == 10)
+        #expect(v1.frame.height == 0)
 
-        XCTAssertEqual(v2.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.origin.x, 62, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v2.frame.origin.y == 0)
+        #expect(v2.frame.origin.x == 62)
+        #expect(v2.frame.width == 0)
+        #expect(v2.frame.height == 0)
     }
-    
+
+    @Test
     func testMarginBetweenTwoViewsRTL() {
         ctrler.view.semanticContentAttribute = .forceRightToLeft
         let v1 = UIView()
@@ -483,24 +499,25 @@ import Stevia
             v2
         }
         for view in ctrler.view.subviews {
-            XCTAssertEqual(view.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+            #expect(view.frame.origin.y == 0)
+            #expect(view.frame.origin.x == 0)
+            #expect(view.frame.width == 0)
+            #expect(view.frame.height == 0)
         }
         |v1.width(10)-52-v2
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v1.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.origin.x, ctrler.view.frame.width - 10, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.width, 10, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v1.frame.origin.y == 0)
+        #expect(v1.frame.origin.x == ctrler.view.frame.width - 10)
+        #expect(v1.frame.width == 10)
+        #expect(v1.frame.height == 0)
         
-        XCTAssertEqual(v2.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.origin.x, ctrler.view.frame.width - 10 - 52, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v2.frame.origin.y == 0)
+        #expect(v2.frame.origin.x == ctrler.view.frame.width - 10 - 52)
+        #expect(v2.frame.width == 0)
+        #expect(v2.frame.height == 0)
     }
     
+    @Test
     func testArrayRightConstraint() {
         let v1 = UIView()
         let v2 = UIView()
@@ -510,30 +527,26 @@ import Stevia
             v2
         }
         for view in ctrler.view.subviews {
-            XCTAssertEqual(view.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+            #expect(view.frame.origin.y == 0)
+            #expect(view.frame.origin.x == 0)
+            #expect(view.frame.width == 0)
+            #expect(view.frame.height == 0)
         }
         
         v1-52-v2.width(10)-31-|
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v1.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.origin.x,
-                                   ctrler.view.frame.width - 31 - v2.frame.width - 52,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
-        
-        XCTAssertEqual(v2.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.origin.x,
-                                   ctrler.view.frame.width - 31 - v2.frame.width,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.width, 10, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v1.frame.origin.y == 0)
+        #expect(v1.frame.origin.x == ctrler.view.frame.width - 31 - v2.frame.width - 52)
+        #expect(v1.frame.width == 0)
+        #expect(v1.frame.height == 0)
         
+        #expect(v2.frame.origin.y == 0)
+        #expect(v2.frame.origin.x == ctrler.view.frame.width - 31 - v2.frame.width)
+        #expect(v2.frame.width == 10)
+        #expect(v2.frame.height == 0)
     }
-    
+
+    @Test
     func testArrayRightConstraintRTL() {
         ctrler.view.semanticContentAttribute = .forceRightToLeft
         let v1 = UIView()
@@ -544,25 +557,23 @@ import Stevia
             v2
         }
         for view in ctrler.view.subviews {
-            XCTAssertEqual(view.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+            #expect(view.frame.origin.y == 0)
+            #expect(view.frame.origin.x == 0)
+            #expect(view.frame.width == 0)
+            #expect(view.frame.height == 0)
         }
         
         v1-52-v2.width(10)-31-|
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v1.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.origin.x, 31 + v2.frame.width + 52,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
-        
-        XCTAssertEqual(v2.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.origin.x, 31, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.width, 10, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v1.frame.origin.y == 0)
+        #expect(v1.frame.origin.x == 31 + v2.frame.width + 52)
+        #expect(v1.frame.width == 0)
+        #expect(v1.frame.height == 0)
         
+        #expect(v2.frame.origin.y == 0)
+        #expect(v2.frame.origin.x == 31)
+        #expect(v2.frame.width == 10)
+        #expect(v2.frame.height == 0)
     }
     
     func testDefaultMarginBetweenThreeViews() {
@@ -576,32 +587,30 @@ import Stevia
             v3
         }
         for view in ctrler.view.subviews {
-            XCTAssertEqual(view.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+            #expect(view.frame.origin.y == 0)
+            #expect(view.frame.origin.x == 0)
+            #expect(view.frame.width == 0)
+            #expect(view.frame.height == 0)
         }
-        
 
         |v1.width(20)⁃v2.width(20)⁃v3
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v1.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.width, 20, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
-        
-        XCTAssertEqual(v2.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.origin.x, 28, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.width, 20, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v3.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v3.frame.origin.x, v2.frame.origin.x + v2.frame.width + 8,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v3.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v3.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v1.frame.origin.y == 0)
+        #expect(v1.frame.origin.x == 0)
+        #expect(v1.frame.width == 20)
+        #expect(v1.frame.height == 0)
         
+        #expect(v2.frame.origin.y == 0)
+        #expect(v2.frame.origin.x == 28)
+        #expect(v2.frame.width == 20)
+        #expect(v2.frame.height == 0)
+        #expect(v3.frame.origin.y == 0)
+        #expect(v3.frame.origin.x == v2.frame.origin.x + v2.frame.width + 8)
+        #expect(v3.frame.width == 0)
+        #expect(v3.frame.height == 0)
     }
     
+    @Test
     func testMarginsBetweenThreeViewsDouble() {
         let v1 = UIView()
         let v2 = UIView()
@@ -613,10 +622,10 @@ import Stevia
             v3
         }
         for view in ctrler.view.subviews {
-            XCTAssertEqual(view.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+            #expect(view.frame.origin.y == 0)
+            #expect(view.frame.origin.x == 0)
+            #expect(view.frame.width == 0)
+            #expect(view.frame.height == 0)
         }
         
         let m1: Double = 43
@@ -624,24 +633,23 @@ import Stevia
         
         |v1.width(20)-m1-v2.width(20)-m2-v3
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v1.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.width, 20, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v1.frame.origin.y == 0)
+        #expect(v1.frame.origin.x == 0)
+        #expect(v1.frame.width == 20)
+        #expect(v1.frame.height == 0)
         
-        XCTAssertEqual(v2.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.origin.x, v1.frame.origin.x + v1.frame.width + 43,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.width, 20, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v3.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v3.frame.origin.x, v2.frame.origin.x + v2.frame.width + 27,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v3.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v3.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v2.frame.origin.y == 0)
+        #expect(v2.frame.origin.x == v1.frame.origin.x + v1.frame.width + 43)
+        #expect(v2.frame.width == 20)
+        #expect(v2.frame.height == 0)
+        #expect(v3.frame.origin.y == 0)
+        #expect(v3.frame.origin.x == v2.frame.origin.x + v2.frame.width + 27)
+        #expect(v3.frame.width == 0)
+        #expect(v3.frame.height == 0)
         
     }
-    
+
+    @Test
     func testMarginsBetweenThreeViewsCGFloat() {
         let v1 = UIView()
         let v2 = UIView()
@@ -653,10 +661,10 @@ import Stevia
             v3
         }
         for view in ctrler.view.subviews {
-            XCTAssertEqual(view.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+            #expect(view.frame.origin.y == 0)
+            #expect(view.frame.origin.x == 0)
+            #expect(view.frame.width == 0)
+            #expect(view.frame.height == 0)
         }
         
         let m1: CGFloat = 43
@@ -664,24 +672,22 @@ import Stevia
         
         |v1.width(20)-m1-v2.width(20)-m2-v3
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v1.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.width, 20, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
-        
-        XCTAssertEqual(v2.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.origin.x, v1.frame.origin.x + v1.frame.width + 43,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.width, 20, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v3.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v3.frame.origin.x, v2.frame.origin.x + v2.frame.width + 27,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v3.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v3.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v1.frame.origin.y == 0)
+        #expect(v1.frame.origin.x == 0)
+        #expect(v1.frame.width == 20)
+        #expect(v1.frame.height == 0)
         
+        #expect(v2.frame.origin.y == 0)
+        #expect(v2.frame.origin.x == v1.frame.origin.x + v1.frame.width + 43)
+        #expect(v2.frame.width == 20)
+        #expect(v2.frame.height == 0)
+        #expect(v3.frame.origin.y == 0)
+        #expect(v3.frame.origin.x == v2.frame.origin.x + v2.frame.width + 27)
+        #expect(v3.frame.width == 0)
+        #expect(v3.frame.height == 0)
     }
-    
+
+    @Test
     func testMarginsBetweenThreeViewsInt() {
         let v1 = UIView()
         let v2 = UIView()
@@ -693,10 +699,10 @@ import Stevia
             v3
         }
         for view in ctrler.view.subviews {
-            XCTAssertEqual(view.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+            #expect(view.frame.origin.y == 0)
+            #expect(view.frame.origin.x == 0)
+            #expect(view.frame.width == 0)
+            #expect(view.frame.height == 0)
         }
         
         let m1: Int = 43
@@ -704,22 +710,19 @@ import Stevia
         
         |v1.width(20)-m1-v2.width(20)-m2-v3
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v1.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.width, 20, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
-        
-        XCTAssertEqual(v2.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.origin.x, v1.frame.origin.x + v1.frame.width + 43,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.width, 20, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v3.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v3.frame.origin.x, v2.frame.origin.x + v2.frame.width + 27,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v3.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v3.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v1.frame.origin.y == 0)
+        #expect(v1.frame.origin.x == 0)
+        #expect(v1.frame.width == 20)
+        #expect(v1.frame.height == 0)
         
+        #expect(v2.frame.origin.y == 0)
+        #expect(v2.frame.origin.x == v1.frame.origin.x + v1.frame.width + 43)
+        #expect(v2.frame.width == 20)
+        #expect(v2.frame.height == 0)
+        #expect(v3.frame.origin.y == 0)
+        #expect(v3.frame.origin.x == v2.frame.origin.x + v2.frame.width + 27)
+        #expect(v3.frame.width == 0)
+        #expect(v3.frame.height == 0)
     }
     
     func testMarginsBetweenThreeViewsRTL() {
@@ -734,32 +737,31 @@ import Stevia
             v3
         }
         for view in ctrler.view.subviews {
-            XCTAssertEqual(view.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+            #expect(view.frame.origin.y == 0)
+            #expect(view.frame.origin.x == 0)
+            #expect(view.frame.width == 0)
+            #expect(view.frame.height == 0)
         }
         
         |v1.width(20)-43-v2.width(20)-27-v3
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v1.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.origin.x, ctrler.view.frame.width - 20, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.width, 20, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
-        
-        XCTAssertEqual(v2.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.origin.x, ctrler.view.frame.width - v1.frame.width - 43 - v2.frame.width,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.width, 20, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v3.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v3.frame.origin.x, ctrler.view.frame.width - v1.frame.width - 43 - v2.frame.width - 27,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v3.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v3.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
-        
+        #expect(v1.frame.origin.y == 0)
+        #expect(v1.frame.origin.x == ctrler.view.frame.width - 20)
+        #expect(v1.frame.width == 20)
+        #expect(v1.frame.height == 0)
+        
+        #expect(v2.frame.origin.y == 0)
+        #expect(v2.frame.origin.x == ctrler.view.frame.width - v1.frame.width - 43 - v2.frame.width)
+        #expect(v2.frame.width == 20)
+        #expect(v2.frame.height == 0)
+        #expect(v3.frame.origin.y == 0)
+        let val = ctrler.view.frame.width - v1.frame.width - 43 - v2.frame.width - 27
+        #expect(v3.frame.origin.x == val)
+        #expect(v3.frame.width == 0)
+        #expect(v3.frame.height == 0)
     }
-    
+
+    @Test
     func testSpaceBetweenTwoViews() {
         let v1 = UIView()
         let v2 = UIView()
@@ -769,27 +771,27 @@ import Stevia
             v2
         }
         for view in ctrler.view.subviews {
-            XCTAssertEqual(view.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+            #expect(view.frame.origin.y == 0)
+            #expect(view.frame.origin.x == 0)
+            #expect(view.frame.width == 0)
+            #expect(view.frame.height == 0)
         }
         
         |v1.width(20)-""-v2.width(20)|
         ctrler.view.layoutIfNeeded()
         
-        XCTAssertEqual(v1.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.width, 20, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v1.frame.origin.y == 0)
+        #expect(v1.frame.origin.x == 0)
+        #expect(v1.frame.width == 20)
+        #expect(v1.frame.height == 0)
         
-        XCTAssertEqual(v2.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.origin.x, ctrler.view.frame.width - v2.frame.width,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.width, 20, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v2.frame.origin.y == 0)
+        #expect(v2.frame.origin.x == ctrler.view.frame.width - v2.frame.width)
+        #expect(v2.frame.width == 20)
+        #expect(v2.frame.height == 0)
     }
-    
+
+    @Test
     func testSpaceBetweenTwoViewsRTL() {
         ctrler.view.semanticContentAttribute = .forceRightToLeft
         let v1 = UIView()
@@ -800,27 +802,27 @@ import Stevia
             v2
         }
         for view in ctrler.view.subviews {
-            XCTAssertEqual(view.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+            #expect(view.frame.origin.y == 0)
+            #expect(view.frame.origin.x == 0)
+            #expect(view.frame.width == 0)
+            #expect(view.frame.height == 0)
         }
         
         |v1.width(20)-""-v2.width(20)|
         ctrler.view.layoutIfNeeded()
         
-        XCTAssertEqual(v1.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.origin.x, ctrler.view.frame.width - v1.frame.width, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.width, 20, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v1.frame.origin.y == 0)
+        #expect(v1.frame.origin.x == ctrler.view.frame.width - v1.frame.width)
+        #expect(v1.frame.width == 20)
+        #expect(v1.frame.height == 0)
         
-        XCTAssertEqual(v2.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.origin.x, 0,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.width, 20, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v2.frame.origin.y == 0)
+        #expect(v2.frame.origin.x == 0)
+        #expect(v2.frame.width == 20)
+        #expect(v2.frame.height == 0)
     }
-    
+
+    @Test
     func testSpaceWithArrayOfViews() {
         let v1 = UIView()
         let v2 = UIView()
@@ -828,37 +830,36 @@ import Stevia
         v.removeFromSuperview()
         ctrler.view.subviews { v1; v2; v3 }
         for view in ctrler.view.subviews {
-            XCTAssertEqual(view.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-            XCTAssertEqual(view.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+            #expect(view.frame.origin.y == 0)
+            #expect(view.frame.origin.x == 0)
+            #expect(view.frame.width == 0)
+            #expect(view.frame.height == 0)
         }
         
         |v1.width(20)-v2.width(30)-""-v3.width(10)|
         ctrler.view.layoutIfNeeded()
         
-        XCTAssertEqual(v1.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.width, 20, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v1.frame.origin.y == 0)
+        #expect(v1.frame.origin.x == 0)
+        #expect(v1.frame.width == 20)
+        #expect(v1.frame.height == 0)
         
-        XCTAssertEqual(v2.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.origin.x, v1.frame.width + 8,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.width, 30, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v2.frame.origin.y == 0)
+        #expect(v2.frame.origin.x == v1.frame.width + 8)
+        #expect(v2.frame.width == 30)
+        #expect(v2.frame.height == 0)
         
-        XCTAssertEqual(v3.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v3.frame.origin.x, ctrler.view.frame.width - v3.frame.width,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v3.frame.width, 10, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v3.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v3.frame.origin.y == 0)
+        #expect(v3.frame.origin.x == ctrler.view.frame.width - v3.frame.width)
+        #expect(v3.frame.width == 10)
+        #expect(v3.frame.height == 0)
     }
     
+    @Test
     func verifyViewHasDefaultValues() {
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == 0)
+        #expect(v.frame.width == 0)
+        #expect(v.frame.height == 0)
     }
 }
diff --git a/Tests/SteviaTests/PositionTests.swift b/Tests/SteviaTests/PositionTests.swift
index a98aaf97..ac9286d5 100644
--- a/Tests/SteviaTests/PositionTests.swift
+++ b/Tests/SteviaTests/PositionTests.swift
@@ -6,271 +6,282 @@
 //  Copyright © 2016 Sacha Durand Saint Omer. All rights reserved.
 //
 
-import XCTest
+import Testing
+import UIKit
 import Stevia
 
-@MainActor class PositionTests: XCTestCase {
+@Suite
+@MainActor class PositionTests {
     
-    var win: UIWindow!
-    var ctrler: UIViewController!
-    var v: UIView!
+    let win = UIWindow(frame: UIScreen.main.bounds)
+    let ctrler =  UIViewController()
+    let v = UIView()
     
-    override func setUp() async throws {
-//        super.setUp()
-        win = UIWindow(frame: UIScreen.main.bounds)
-        ctrler =  UIViewController()
+    init() {
         win.rootViewController = ctrler
-        v = UIView()
-        ctrler.view.subviews { v! }
+        ctrler.view.subviews { v }
         v.size(100.0)
     }
-    
-    override func tearDown() {
-        super.tearDown()
-    }
-    
+
+    @Test
     func testTopDouble() {
         v.top(Double(23))
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 23, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 23)
+        #expect(v.frame.origin.x == 0)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testTopCGFloat() {
         v.top(CGFloat(23))
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 23, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 23)
+        #expect(v.frame.origin.x == 0)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testTopInt() {
         v.top(Int(23))
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 23, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 23)
+        #expect(v.frame.origin.x == 0)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testBottomDouble() {
         v.bottom(Double(45))
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, ctrler.view.frame.height - v.frame.height - 45,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == ctrler.view.frame.height - v.frame.height - 45)
+        #expect(v.frame.origin.x == 0)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testBottomCGFloat() {
         v.bottom(CGFloat(45))
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, ctrler.view.frame.height - v.frame.height - 45,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == ctrler.view.frame.height - v.frame.height - 45)
+        #expect(v.frame.origin.x == 0)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testBottomInt() {
         v.bottom(Int(45))
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, ctrler.view.frame.height - v.frame.height - 45,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == ctrler.view.frame.height - v.frame.height - 45)
+        #expect(v.frame.origin.x == 0)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testLeftDouble() {
         v.left(Double(12))
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 12, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == 12)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testLeftCGFloat() {
         v.left(CGFloat(12))
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 12, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == 12)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testLeftInt() {
         v.left(Int(12))
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 12, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == 12)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testLeadingDouble() {
         v.leading(Double(12))
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 12, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == 12)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testLeadingCGFloat() {
         v.leading(CGFloat(12))
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 12, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == 12)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testLeadingInt() {
         v.leading(Int(12))
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x, 12, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == 12)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testRightDouble() {
         v.right(Double(74))
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x,  ctrler.view.frame.width - v.frame.width - 74,
-                       accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == ctrler.view.frame.width - v.frame.width - 74)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testRightCGFloat() {
         v.right(CGFloat(74))
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x,  ctrler.view.frame.width - v.frame.width - 74,
-                       accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == ctrler.view.frame.width - v.frame.width - 74)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testRightInt() {
         v.right(Int(74))
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x,  ctrler.view.frame.width - v.frame.width - 74,
-                       accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == ctrler.view.frame.width - v.frame.width - 74)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testTrailingDouble() {
         v.trailing(Double(74))
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x,  ctrler.view.frame.width - v.frame.width - 74,
-                       accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == ctrler.view.frame.width - v.frame.width - 74)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testTrailingCGFloat() {
         v.trailing(CGFloat(74))
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x,  ctrler.view.frame.width - v.frame.width - 74,
-                       accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == ctrler.view.frame.width - v.frame.width - 74)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testTrailingInt() {
         v.trailing(Int(74))
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x,  ctrler.view.frame.width - v.frame.width - 74,
-                       accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == ctrler.view.frame.width - v.frame.width - 74)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testPercentTop() {
         v.top(10%)
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, ctrler.view.frame.height * (10/100) , accuracy: CGFloat(0.3))
-        XCTAssertEqual(v.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(isApproximatelyEqual(v.frame.origin.y, ctrler.view.frame.height * 0.1))
+        #expect(v.frame.origin.x == 0)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testPercentBottom() {
         v.bottom(10%)
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, ctrler.view.frame.height * (90/100) - v.frame.height, accuracy: CGFloat(0.3))
-        XCTAssertEqual(v.frame.origin.x, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(isApproximatelyEqual(v.frame.origin.y, ctrler.view.frame.height * 0.9 - v.frame.height))
+        #expect(v.frame.origin.x == 0)
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testPercentLeft() {
         v.left(10%)
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0 , accuracy: CGFloat(0.1))
-        XCTAssertEqual(v.frame.origin.x, ctrler.view.frame.width * (10/100), accuracy: CGFloat(0.1))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(isApproximatelyEqual(v.frame.origin.x, ctrler.view.frame.width * 0.1))
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testPercentRight() {
         v.right(10%)
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0 , accuracy: CGFloat(0.1))
-        XCTAssertEqual(v.frame.origin.x, ctrler.view.frame.width * (90/100) - v.frame.width, accuracy: CGFloat(0.2))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(isApproximatelyEqual(v.frame.origin.x, ctrler.view.frame.width * 0.9 - v.frame.width))
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testPercentLeading() {
         v.leading(10%)
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0 , accuracy: CGFloat(0.1))
-        XCTAssertEqual(v.frame.origin.x, ctrler.view.frame.width * (10/100), accuracy: CGFloat(0.1))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(isApproximatelyEqual(v.frame.origin.x, ctrler.view.frame.width * 0.1))
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testPercentTrailing() {
         v.trailing(10%)
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0 , accuracy: CGFloat(0.1))
-        XCTAssertEqual(v.frame.origin.x, ctrler.view.frame.width * (90/100) - v.frame.width, accuracy: CGFloat(0.2))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(isApproximatelyEqual(v.frame.origin.x, ctrler.view.frame.width * 0.9 - v.frame.width))
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testPercentLeadingRTL() {
         ctrler.view.semanticContentAttribute = .forceRightToLeft
         v.leading(10%)
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0 , accuracy: CGFloat(0.1))
-        XCTAssertEqual(v.frame.origin.x, ctrler.view.frame.width * (90/100) - v.frame.width, accuracy: CGFloat(0.2))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(isApproximatelyEqual(v.frame.origin.x, (ctrler.view.frame.width * 0.9 - v.frame.width)))
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
     
+    @Test
     func testPercentTrailingRTL() {
         ctrler.view.semanticContentAttribute = .forceRightToLeft
         v.trailing(10%)
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0 , accuracy: CGFloat(0.1))
-        XCTAssertEqual(v.frame.origin.x, ctrler.view.frame.width * (10/100), accuracy: CGFloat(0.1))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(isApproximatelyEqual(v.frame.origin.x, ctrler.view.frame.width * 0.1))
+        #expect(v.frame.width == 100)
+        #expect(v.frame.height == 100)
     }
 }
diff --git a/Tests/SteviaTests/SizeTests.swift b/Tests/SteviaTests/SizeTests.swift
index 0ad681d0..b468f331 100644
--- a/Tests/SteviaTests/SizeTests.swift
+++ b/Tests/SteviaTests/SizeTests.swift
@@ -6,117 +6,110 @@
 //  Copyright © 2016 Sacha Durand Saint Omer. All rights reserved.
 //
 
-import XCTest
+import Testing
+import UIKit
 import Stevia
 
-@MainActor class SizeTests: XCTestCase {
+@Suite
+@MainActor struct SizeTests {
     
-    var win: UIWindow!
-    var ctrler: UIViewController!
-    var v: UIView!
+    let win = UIWindow(frame: UIScreen.main.bounds)
+    let ctrler = UIViewController()
+    let v = UIView()
     
-    override func setUp() async throws {
-//        try await super.setUp()
-        win = UIWindow(frame: UIScreen.main.bounds)
-        ctrler =  UIViewController()
+    init() {
         win.rootViewController = ctrler
-        v = UIView()
         ctrler.view.subviews {
-            v!
+            v
         }
     }
     
-    func uiSetUp() {
-        win = UIWindow(frame: UIScreen.main.bounds)
-        ctrler =  UIViewController()
-        win.rootViewController = ctrler
-        v = UIView()
-        ctrler.view.subviews {
-            v!
-        }
-    }
-    
-    override func tearDown() {
-        super.tearDown()
-    }
-    
+    @Test
     func testSizeDouble() {
         v.size(Double(57))
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x,  0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 57, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 57, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == 0)
+        #expect(v.frame.width == 57)
+        #expect(v.frame.height == 57)
     }
     
+    @Test
     func testSizeCGFloat() {
         v.size(CGFloat(57))
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x,  0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 57, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 57, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == 0)
+        #expect(v.frame.width == 57)
+        #expect(v.frame.height == 57)
     }
     
+    @Test
     func testSizeInt() {
         v.size(Int(57))
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x,  0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 57, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 57, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == 0)
+        #expect(v.frame.width == 57)
+        #expect(v.frame.height == 57)
     }
     
+    @Test
     func testWidthAndHeightDouble() {
         v.width(Double(36))
         v.height(Double(23))
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x,  0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 36, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 23, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == 0)
+        #expect(v.frame.width == 36)
+        #expect(v.frame.height == 23)
     }
     
+    @Test
     func testWidthAndHeightCGFloat() {
         v.width(CGFloat(36))
         v.height(CGFloat(23))
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x,  0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 36, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 23, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == 0)
+        #expect(v.frame.width == 36)
+        #expect(v.frame.height == 23)
     }
     
+    @Test
     func testWidthAndHeightInt() {
         v.width(Int(36))
         v.height(Int(23))
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x,  0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 36, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 23, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == 0)
+        #expect(v.frame.width == 36)
+        #expect(v.frame.height == 23)
     }
     
+    @Test
     func testHeightPercentage() {
         v.width(100)
         v.height(40%)
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x,  0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 100, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, ctrler.view.frame.height*0.4, accuracy:0.5)
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == 0)
+        #expect(v.frame.width == 100)
+        #expect(isApproximatelyEqual(v.frame.height, ctrler.view.frame.height*0.4))
     }
     
+    @Test
     func testWidthPercentage() {
         v.height(100)
         v.width(87%)
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x,  0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, ctrler.view.frame.width*0.87, accuracy: 0.5)
-        XCTAssertEqual(v.frame.height, 100, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == 0)
+        #expect(v.frame.height == 100)
+        #expect(isApproximatelyEqual(v.frame.width, ctrler.view.frame.width*0.87))
     }
     
+    @Test
     func testEqualSizes() {
         let width = 24.0
         let height = 267.0
@@ -130,10 +123,11 @@ import Stevia
         v1.width(width)
         equal(sizes: [v1, v2])
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v1.frame.width, v2.frame.width, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.height, v2.frame.height, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v1.frame.width == v2.frame.width)
+        #expect(v1.frame.height == v2.frame.height)
     }
 
+    @Test
     func testVariadicEqualSizes() {
         let width = 24.0
         let height = 267.0
@@ -147,10 +141,11 @@ import Stevia
         v1.width(width)
         equal(sizes: v1, v2)
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v1.frame.width, v2.frame.width, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.height, v2.frame.height, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v1.frame.width == v2.frame.width)
+        #expect(v1.frame.height == v2.frame.height)
     }
 
+    @Test
     func testFollwEdges() {
         let v1 = UIView()
         let v2 = UIView()
@@ -166,67 +161,62 @@ import Stevia
             |-20-v1| ~ 32
         }
         
-
         ctrler.view.layoutIfNeeded()
         
-        XCTAssertEqual(v1.frame.origin.y, 10, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.origin.x,  20, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.width, ctrler.view.frame.width - 20,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v1.frame.height, 32, accuracy: CGFloat(Float.ulpOfOne))
-        
-        
-        XCTAssertEqual(v2.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.origin.x,  0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.width, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.height, 0, accuracy: CGFloat(Float.ulpOfOne))
-        
+        #expect(v1.frame.origin.y == 10)
+        #expect(v1.frame.origin.x == 20)
+        #expect(v1.frame.width == ctrler.view.frame.width - 20)
+        #expect(v1.frame.height == 32)
+
+        #expect(v2.frame.origin.y == 0)
+        #expect(v2.frame.origin.x == 0)
+        #expect(v2.frame.width == 0)
+        #expect(v2.frame.height == 0)
+
         v2.followEdges(v1)
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v2.frame.origin.y, v1.frame.origin.y,
-                                   accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.origin.x, v1.frame.origin.x,
-                       accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.width, v1.frame.width, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v2.frame.height, v1.frame.height, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v2.frame.origin.y == v1.frame.origin.y)
+        #expect(v2.frame.origin.x == v1.frame.origin.x)
+        #expect(v2.frame.width == v1.frame.width)
+        #expect(v2.frame.height == v1.frame.height)
     }
-    
-    
+
+    @Test
     func testHeightEqualWidth() {
         v.heightEqualsWidth().width(85)
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x,  0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 85, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 85, accuracy: CGFloat(Float.ulpOfOne))
-
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == 0)
+        #expect(v.frame.width == 85)
+        #expect(v.frame.height == 85)
     }
 
+    @Test
     func testWidthEqualHeight() {
         v.height(192)
         v.heightEqualsWidth()
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.origin.y, 0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.origin.x,  0, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.width, 192, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 192, accuracy: CGFloat(Float.ulpOfOne))
-        
+        #expect(v.frame.origin.y == 0)
+        #expect(v.frame.origin.x == 0)
+        #expect(v.frame.width == 192)
+        #expect(v.frame.height == 192)
     }
     
+    @Test
     func testSizeOnOrphanView() {
         v.removeFromSuperview()
         v.height(80)
         v.width(80)
-        ctrler.view?.subviews { v! }
-        
+        ctrler.view?.subviews { v }
+    
         let view: UIView = ctrler.view
         view.layout {
             0
-            |v!
+            |v
         }
         
         ctrler.view.layoutIfNeeded()
-        XCTAssertEqual(v.frame.width, 80, accuracy: CGFloat(Float.ulpOfOne))
-        XCTAssertEqual(v.frame.height, 80, accuracy: CGFloat(Float.ulpOfOne))
+        #expect(v.frame.width == 80)
+        #expect(v.frame.height == 80)
     }
 }
diff --git a/Tests/SteviaTests/StyleTests.swift b/Tests/SteviaTests/StyleTests.swift
index 6c7a173a..ec4b1f20 100644
--- a/Tests/SteviaTests/StyleTests.swift
+++ b/Tests/SteviaTests/StyleTests.swift
@@ -6,10 +6,12 @@
 //  Copyright © 2016 Sacha Durand Saint Omer. All rights reserved.
 //
 
-import XCTest
+import Testing
+import UIKit
 import Stevia
 
-@MainActor class StyleTests: XCTestCase {
+@Suite
+@MainActor struct StyleTests {
 
     func styleView(_ view: UIView) {
         view.backgroundColor = UIColor.yellow
@@ -19,7 +21,8 @@ import Stevia
         label.textColor = UIColor.yellow
     }
 
-    func testStyle() {
+    @Test
+    func canCallStyle() {
         let label = UILabel()
         
         label.style(styleLabel).style(styleView)
@@ -28,13 +31,13 @@ import Stevia
         let view: UIView = label
         view.style(styleView)
         
-        XCTAssertEqual(view.backgroundColor, UIColor.yellow)
-        XCTAssertEqual(label.textColor, UIColor.yellow)
+        #expect(view.backgroundColor == UIColor.yellow)
+        #expect(label.textColor == UIColor.yellow)
         
         //check type deduction
         label.style { (label) -> () in
             label.textColor = UIColor.blue
         }
-        XCTAssertEqual(label.textColor, UIColor.blue)
+        #expect(label.textColor == UIColor.blue)
     }
 }
diff --git a/Tests/SteviaTests/XCTestManifests.swift b/Tests/SteviaTests/XCTestManifests.swift
deleted file mode 100644
index 3910b005..00000000
--- a/Tests/SteviaTests/XCTestManifests.swift
+++ /dev/null
@@ -1,9 +0,0 @@
-import XCTest
-
-#if !canImport(ObjectiveC)
-public func allTests() -> [XCTestCaseEntry] {
-    return [
-        testCase(SteviaTests.allTests),
-    ]
-}
-#endif