diff --git a/Tests/SwiftDocCTests/Utility/SynchronizationTests.swift b/Tests/SwiftDocCTests/Utility/SynchronizationTests.swift
index eb20e7aa96..846ab41b83 100644
--- a/Tests/SwiftDocCTests/Utility/SynchronizationTests.swift
+++ b/Tests/SwiftDocCTests/Utility/SynchronizationTests.swift
@@ -10,6 +10,29 @@
 
 import XCTest
 @testable import SwiftDocC
+#if os(Windows)
+import func WinSDK.TryAcquireSRWLockExclusive
+#endif
+
+private func XCTAssertLockIsUnlocked<T>(_ synced: Synchronized<T>) {
+    #if os(macOS) || os(iOS)
+    XCTAssertTrue(os_unfair_lock_trylock(synced.lock))
+    #elseif os(Windows)
+    XCTAssertNotEqual(TryAcquireSRWLockExclusive(synced.lock), 0)
+    #else
+    XCTAssertEqual(pthread_mutex_trylock(synced.lock), 0)
+    #endif
+}
+
+private func XCTAssertLockIsLocked<T>(_ synced: Synchronized<T>) {
+    #if os(macOS) || os(iOS)
+    XCTAssertFalse(os_unfair_lock_trylock(synced.lock))
+    #elseif os(Windows)
+    XCTAssertEqual(TryAcquireSRWLockExclusive(synced.lock), 0)
+    #else
+    XCTAssertNotEqual(pthread_mutex_trylock(synced.lock), 0)
+    #endif
+}
 
 class SynchronizationTests: XCTestCase {
     func testInitialState() {
@@ -19,11 +42,7 @@ class SynchronizationTests: XCTestCase {
         XCTAssertEqual(synced.sync({ $0 }), false)
         
         // Verify the lock is unlocked
-        #if os(macOS) || os(iOS)
-        XCTAssertTrue(os_unfair_lock_trylock(synced.lock))
-        #else
-        XCTAssertEqual(pthread_mutex_trylock(synced.lock),0)
-        #endif
+        XCTAssertLockIsUnlocked(synced)
     }
     
     func testUpdatesWrappedValue() {
@@ -42,11 +61,7 @@ class SynchronizationTests: XCTestCase {
         XCTAssertEqual(synced.sync({ $0 }), true)
         
         // Verify the lock is unlocked after running the block
-        #if os(macOS) || os(iOS)
-        XCTAssertTrue(os_unfair_lock_trylock(synced.lock))
-        #else
-        XCTAssertEqual(pthread_mutex_trylock(synced.lock),0)
-        #endif
+        XCTAssertLockIsUnlocked(synced)
     }
     
     func testLocksLockDuringPerformingWork() {
@@ -64,11 +79,7 @@ class SynchronizationTests: XCTestCase {
         // Asynchronously perform a check after 0.25 secs that the lock is locked
         testQueue.asyncAfter(deadline: .now() + 0.25) {
             // Verify the used lock is lock in here
-            #if os(macOS) || os(iOS)
-            XCTAssertFalse(os_unfair_lock_trylock(synced.lock))
-            #else
-            XCTAssertNotEqual(pthread_mutex_trylock(synced.lock),0)
-            #endif
+            XCTAssertLockIsLocked(synced)
             didTest.fulfill()
         }
 
@@ -88,11 +99,7 @@ class SynchronizationTests: XCTestCase {
         }
         
         // Verify that the lock is unlocked after re-throwing
-        #if os(macOS) || os(iOS)
-        XCTAssertTrue(os_unfair_lock_trylock(synced.lock))
-        #else
-        XCTAssertEqual(pthread_mutex_trylock(synced.lock),0)
-        #endif
+        XCTAssertLockIsUnlocked(synced)
     }
 
     func testBlocking() {
@@ -126,11 +133,7 @@ class SynchronizationTests: XCTestCase {
         let synced = Lock()
                 
         // Verify the lock is unlocked
-        #if os(macOS) || os(iOS)
-        XCTAssertTrue(os_unfair_lock_trylock(synced.lock))
-        #else
-        XCTAssertEqual(pthread_mutex_trylock(synced.lock), 0)
-        #endif
+        XCTAssertLockIsUnlocked(synced)
     }
     
     func testBlockingWithLock() {