Add test for async.

src/test/scala/scalauv/AsyncSpec.scala

@@ -0,0 +1,51 @@
+package scalauv
+
+import org.junit.Test
+import org.junit.Assert.*
+import scalanative.unsafe.*
+import scalanative.unsigned.*
+
+final class AsyncSpec {
+
+  import AsyncSpec.*
+
+  @Test
+  def runsAnAsyncCallback(): Unit = {
+    withZone {
+      val loop = LibUv.uv_default_loop()
+
+      val asyncHandle = AsyncHandle.zoneAllocate()
+
+      UvUtils.attempt {
+        LibUv.uv_async_init(loop, asyncHandle, callback).checkErrorThrowIO()
+
+        UvUtils.onFail(LibUv.uv_close(asyncHandle, closeCallback))
+
+        LibUv.uv_async_send(asyncHandle).checkErrorThrowIO()
+      }
+
+      LibUv.uv_run(loop, RunMode.DEFAULT).checkErrorThrowIO()
+      ()
+    }
+
+    assertTrue("callback was run", callbackRun)
+    assertTrue("handle was closed", closed)
+  }
+
+}
+
+object AsyncSpec {
+
+  private var callbackRun = false
+
+  private var closed = false
+
+  private val closeCallback: LibUv.CloseCallback = { (handle: Handle) =>
+    closed = true
+  }
+
+  private val callback: LibUv.AsyncCallback = { (handle: AsyncHandle) =>
+    callbackRun = true
+    LibUv.uv_close(handle, closeCallback)
+  }
+}

src/test/scala/scalauv/TcpSpec.scala

@@ -1,4 +1,5 @@
 package scalauv
+
 import org.junit.Test
 import org.junit.Assert.*
 import LibUv.*
@@ -10,42 +11,6 @@ final class TcpSpec {
 
   import TcpSpec.*
 
-  def recordReceived(s: String): Unit = {
-    receivedData = receivedData :+ s
-  }
-
-  def setFailed(msg: String): Unit = {
-    failed = Some(msg)
-  }
-
-  def onClose: CloseCallback = (h: Handle) => stdlib.free(h.toPtr)
-
-  def onRead: StreamReadCallback = {
-    (handle: StreamHandle, numRead: CSSize, buf: Buffer) =>
-      numRead match {
-        case ErrorCodes.EOF =>
-          uv_close(handle, onClose)
-        case code if code < 0 =>
-          uv_close(handle, onClose)
-          setFailed(UvUtils.errorMessage(code.toInt))
-        case _ =>
-          val (text, done) =
-            buf.asUtf8String(numRead.toInt).span(_ != DoneMarker)
-          recordReceived(text)
-          if done.nonEmpty then {
-            val listenHandle = Handle.unsafeFromPtr(uv_handle_get_data(handle))
-            uv_close(listenHandle, null)
-          }
-      }
-      stdlib.free(buf.base)
-  }
-
-  @Test
-  def foo(): Unit = {
-    println("XXXXXX")
-    assertEquals(1, 1)
-  }
-
   @Test
   def listen(): Unit = {
 
@@ -152,4 +117,34 @@ object TcpSpec {
   private var receivedData = Vector.empty[String]
   private var failed = Option.empty[String]
 
+  def recordReceived(s: String): Unit = {
+    receivedData = receivedData :+ s
+  }
+
+  def setFailed(msg: String): Unit = {
+    failed = Some(msg)
+  }
+
+  def onClose: CloseCallback = (h: Handle) => stdlib.free(h.toPtr)
+
+  def onRead: StreamReadCallback = {
+    (handle: StreamHandle, numRead: CSSize, buf: Buffer) =>
+      numRead match {
+        case ErrorCodes.EOF =>
+          uv_close(handle, onClose)
+        case code if code < 0 =>
+          uv_close(handle, onClose)
+          setFailed(UvUtils.errorMessage(code.toInt))
+        case _ =>
+          val (text, done) =
+            buf.asUtf8String(numRead.toInt).span(_ != DoneMarker)
+          recordReceived(text)
+          if done.nonEmpty then {
+            val listenHandle = Handle.unsafeFromPtr(uv_handle_get_data(handle))
+            uv_close(listenHandle, null)
+          }
+      }
+      stdlib.free(buf.base)
+  }
+
 }