reverts threading problems due to previous shimming experiments

lib/zig/templates/threaded.zig.eex

@@ -38,26 +38,23 @@ fn @"<%= @type.name %>-join"(env: beam.env, argc: c_int, args: [*c] const e.ErlN
     _ = argc;
     // set beam.allocator due to reentry
     beam.allocator = beam.raw_allocator;
-    _ = args;
-    const thread_rsrc: ThreadResource_<%= @type.name %> = undefined;
-    //const thread_rsrc = beam.get(ThreadResource_<%= @type.name %>, env, .{.v = args[0]}, .{}) catch {
-    //    @panic("error getting thread resource");
-    //};
+    const thread_rsrc = beam.get(ThreadResource_<%= @type.name %>, env, .{.v = args[0]}, .{}) catch {
+        @panic("error getting thread resource");
+    };
     const thread = ThreadResource_<%= @type.name %>.unpack(thread_rsrc);
+
     const result = thread.join() catch {
         // TODO: fix this
         @panic("error joining thread");
     };
 
     if (comptime Thread_<%= @type.name %>.makes_error_result()) {
         const result_term = switch(result) {
-            .ok => // |ok_result| beam.make(env, ok_result, .{}),
-              beam.raise_exception(env, .foo),
+            .ok => |ok_result| beam.make(env, ok_result, .{}),
             .error_return_trace => |error_result| beam.raise_exception(env, beam.copy(env, error_result)),
         };
         return result_term.v;
     } else {
-        return beam.make(env, .foo, .{}).v;
-        // return beam.make(env, result, .{}).v;
+        return beam.make(env, result, .{}).v;
     }
 }

test/integration/concurrency/threaded_automatic_erroring_test.exs

@@ -6,7 +6,6 @@ defmodule ZiglerTest.Concurrency.ThreadedAutomaticErroringTest do
   use Zig, otp_app: :zigler, nifs: [threaded: [:threaded]]
 
   ~Z"""
-  const std = @import("std");
   const beam = @import("beam");
 
   const ThreadError = error{BadNumber};
@@ -17,23 +16,23 @@ defmodule ZiglerTest.Concurrency.ThreadedAutomaticErroringTest do
   }
   """
 
-  test "threaded function can succeed" #do
-  #  assert 48 = threaded(47)
-  #end
-
-  test "threaded function can error" #do
-  #  error =
-  #    try do
-  #      threaded(42)
-  #    rescue
-  #      e in ErlangError ->
-  #        %{payload: e.original, stacktrace: __STACKTRACE__}
-  #    end
-#
-  #  assert %{payload: :BadNumber, stacktrace: [head | _]} = error
-#
-  #  expected_file = Path.absname(__ENV__.file)
-#
-  #  assert {__MODULE__, :threaded, [:...], [file: ^expected_file, line: 15]} = head
-  #end
+  test "threaded function can succeed" do
+    assert 48 = threaded(47)
+  end
+
+  test "threaded function can error" do
+    error =
+      try do
+        threaded(42)
+      rescue
+        e in ErlangError ->
+          %{payload: e.original, stacktrace: __STACKTRACE__}
+      end
+
+    assert %{payload: :BadNumber, stacktrace: [head | _]} = error
+
+    expected_file = Path.absname(__ENV__.file)
+
+    assert {__MODULE__, :threaded, [:...], [file: ^expected_file, line: 15]} = head
+  end
 end

test/integration/concurrency/threaded_automatic_test.exs

@@ -24,10 +24,10 @@ defmodule ZiglerTest.Concurrency.ThreadedAutomaticTest do
   }
   """
 
-  test "threaded function" # do
-  #  assert :ok = threaded(true, self())
-  #  refute_receive :killed
-  #end
+  test "threaded function" do
+    assert :ok = threaded(true, self())
+    refute_receive :killed
+  end
 
   test "threaded function gc's" do
     this = self()

test/integration/erlang/threaded_test.exs

@@ -5,17 +5,17 @@ defmodule ZiglerTest.Erlang.ThreadedTest do
 
   @moduletag :threaded
 
-  test "threaded function" # do
-  #  {:ok, mod} = :compile.file(@test_file, outdir: :code.lib_dir(:zigler, :ebin))
-  #  Code.ensure_loaded(mod)
-#
-  #  this = self()
-  #  assert :ok = :erlang_threaded_test.threaded(true, this)
-  #  refute_receive :killed
-#
-  #  pid = spawn(fn -> :erlang_threaded_test.threaded(false, this) end)
-  #  :erlang.garbage_collect(pid)
-  #  Process.exit(pid, :kill)
-  #  assert_receive :killed, 500
-  #end
+  test "threaded function" do
+    {:ok, mod} = :compile.file(@test_file, outdir: :code.lib_dir(:zigler, :ebin))
+    Code.ensure_loaded(mod)
+
+    this = self()
+    assert :ok = :erlang_threaded_test.threaded(true, this)
+    refute_receive :killed
+
+    pid = spawn(fn -> :erlang_threaded_test.threaded(false, this) end)
+    :erlang.garbage_collect(pid)
+    Process.exit(pid, :kill)
+    assert_receive :killed, 500
+  end
 end