Implement Oracle deadlock test using cross-update pattern

Oracle can trigger deadlocks (ORA-00060) using the classic cross-update
pattern. Unlike PostgreSQL/SQL Server which roll back the victim's entire
transaction, Oracle only rolls back the victim's statement. This requires
using Task.WhenAny instead of Task.WhenAll, then explicitly rolling back
the victim's transaction to release earlier locks and unblock the other
session.

https://claude.ai/code/session_01WusLPsCyEsDpSbp2Nm6Tkx

Author: claude

EntityFramework.Exceptions/Tests/OracleTests.cs

@@ -1,4 +1,6 @@
-using System.Threading.Tasks;
+using System.Linq;
+using System.Threading.Tasks;
+using EntityFramework.Exceptions.Common;
 using EntityFramework.Exceptions.Oracle;
 using Microsoft.EntityFrameworkCore;
 using Testcontainers.Oracle;
@@ -12,10 +14,51 @@ public OracleTests(OracleTestContextFixture fixture) : base(fixture.DemoContext)
     {
     }
 
-    [Fact(Skip = "Skipping as oracle can't trigger deadlock.")]
-    public override Task Deadlock()
+    [Fact]
+    public override async Task Deadlock()
     {
-        return Task.CompletedTask;
+        var p1 = DemoContext.Products.Add(new() { Name = "Test1" });
+        var p2 = DemoContext.Products.Add(new() { Name = "Test2" });
+        await DemoContext.SaveChangesAsync();
+
+        var id1 = p1.Entity.Id;
+        var id2 = p2.Entity.Id;
+
+        await using var controlContext = new DemoContext(DemoContext.Options);
+        await using var transaction1 = await DemoContext.Database.BeginTransactionAsync();
+        await using var transaction2 = await controlContext.Database.BeginTransactionAsync();
+
+        // Each transaction locks one row
+        await DemoContext.Products.Where(c => c.Id == id1)
+            .ExecuteUpdateAsync(c => c.SetProperty(p => p.Name, "Test11"));
+        await controlContext.Products.Where(c => c.Id == id2)
+            .ExecuteUpdateAsync(c => c.SetProperty(p => p.Name, "Test21"));
+
+        // Start both cross-updates concurrently to create a deadlock cycle
+        var task1 = Task.Run(() => DemoContext.Products
+            .Where(c => c.Id == id2)
+            .ExecuteUpdateAsync(c => c.SetProperty(p => p.Name, "Test22")));
+        var task2 = Task.Run(() => controlContext.Products
+            .Where(c => c.Id == id1)
+            .ExecuteUpdateAsync(c => c.SetProperty(p => p.Name, "Test12")));
+
+        // Oracle only rolls back the victim's statement, not its transaction,
+        // so the non-victim remains blocked. Use WhenAny to catch the victim first.
+        var completedTask = await Task.WhenAny(task1, task2);
+        await Assert.ThrowsAsync<DeadlockException>(() => completedTask);
+
+        // Roll back the victim's transaction to release its earlier locks
+        // and unblock the other session.
+        if (completedTask == task1)
+        {
+            await transaction1.RollbackAsync();
+            await task2;
+        }
+        else
+        {
+            await transaction2.RollbackAsync();
+            await task1;
+        }
     }
 }