SKip decimal tests on Windows

Author: josevalim

test/adbc_connection_test.exs

@@ -5,13 +5,7 @@ defmodule Adbc.ConnectionTest do
   alias Adbc.Connection
 
   setup tags do
-    case Map.get(tags, :driver, :sqlite) do
-      :sqlite ->
-        %{db: start_supervised!({Adbc.Database, driver: :sqlite, uri: ":memory:"})}
-
-      :duckdb ->
-        %{db: start_supervised!({Adbc.Database, driver: :duckdb})}
-    end
+    %{db: start_supervised!({Adbc.Database, driver: :sqlite, uri: ":memory:"})}
   end
 
   describe "start_link" do
@@ -739,96 +733,4 @@ defmodule Adbc.ConnectionTest do
       {:ok, %{}} = Connection.get_table_types(conn)
     end
   end
-
-  describe "duckdb array handling" do
-    @describetag driver: :duckdb
-    test "handles empty string arrays without crashing", %{db: db} do
-      conn = start_supervised!({Connection, database: db})
-
-      # Create a table with array column containing empty arrays
-      {:ok, _} =
-        Connection.query(conn, """
-          CREATE TABLE test_arrays (
-            number INTEGER,
-            array_of_text TEXT[]
-          )
-        """)
-
-      # # Insert data with empty arrays
-      {:ok, _} =
-        Connection.query(conn, """
-          INSERT INTO test_arrays VALUES
-          (1, LIST_VALUE()),
-          (2, '["hello", "world"]'),
-          (4, '["single"]')
-        """)
-
-      assert results =
-               %Adbc.Result{
-                 num_rows: 0,
-                 data: [
-                   %Adbc.Column{
-                     name: "number",
-                     type: :s32,
-                     nullable: true,
-                     metadata: nil
-                   },
-                   %Adbc.Column{
-                     name: "array_of_text",
-                     type:
-                       {:list,
-                        %Adbc.Column{
-                          name: "item",
-                          type: :string,
-                          nullable: true,
-                          metadata: nil
-                        }},
-                     nullable: true,
-                     metadata: nil
-                   }
-                 ]
-               } = Connection.query!(conn, "SELECT * FROM test_arrays ORDER BY number")
-
-      assert %Adbc.Result{
-               data: [
-                 %Adbc.Column{
-                   name: "number",
-                   type: :s32,
-                   nullable: true,
-                   metadata: nil,
-                   data: [1, 2, 4]
-                 },
-                 %Adbc.Column{
-                   name: "array_of_text",
-                   type: :list,
-                   nullable: true,
-                   metadata: nil,
-                   data: [
-                     %Adbc.Column{
-                       name: "item",
-                       type: :string,
-                       nullable: true,
-                       metadata: nil,
-                       data: []
-                     },
-                     %Adbc.Column{
-                       name: "item",
-                       type: :string,
-                       nullable: true,
-                       metadata: nil,
-                       data: ["hello", "world"]
-                     },
-                     %Adbc.Column{
-                       name: "item",
-                       type: :string,
-                       nullable: true,
-                       metadata: nil,
-                       data: ["single"]
-                     }
-                   ]
-                 }
-               ]
-             } = Adbc.Result.materialize(results)
-    end
-  end
 end

test/adbc_duckdb_test.exs

@@ -52,6 +52,7 @@ defmodule Adbc.DuckDBTest do
            } = Adbc.Connection.query!(conn, "SELECT struct_pack(col1 := 1, col2 := 2)")
   end
 
+  @tag :unix
   test "decimal128", %{conn: conn} do
     d1 = Decimal.new("1.2345678912345678912345678912345678912")
     d2 = Decimal.new("-1.2345678912345678912345678912345678912")
@@ -174,4 +175,93 @@ defmodule Adbc.DuckDBTest do
              ]
            } = Adbc.Result.materialize(results)
   end
+
+  @tag :unix
+  @describetag driver: :duckdb
+  test "array handling", %{conn: conn} do
+    # Create a table with array column containing empty arrays
+    {:ok, _} =
+      Connection.query(conn, """
+        CREATE TABLE test_arrays (
+          number INTEGER,
+          array_of_text TEXT[]
+        )
+      """)
+
+    # # Insert data with empty arrays
+    {:ok, _} =
+      Connection.query(conn, """
+        INSERT INTO test_arrays VALUES
+        (1, LIST_VALUE()),
+        (2, '["hello", "world"]'),
+        (4, '["single"]')
+      """)
+
+    assert results =
+             %Adbc.Result{
+               num_rows: 0,
+               data: [
+                 %Adbc.Column{
+                   name: "number",
+                   type: :s32,
+                   nullable: true,
+                   metadata: nil
+                 },
+                 %Adbc.Column{
+                   name: "array_of_text",
+                   type:
+                     {:list,
+                      %Adbc.Column{
+                        name: "item",
+                        type: :string,
+                        nullable: true,
+                        metadata: nil
+                      }},
+                   nullable: true,
+                   metadata: nil
+                 }
+               ]
+             } = Connection.query!(conn, "SELECT * FROM test_arrays ORDER BY number")
+
+    assert %Adbc.Result{
+             data: [
+               %Adbc.Column{
+                 name: "number",
+                 type: :s32,
+                 nullable: true,
+                 metadata: nil,
+                 data: [1, 2, 4]
+               },
+               %Adbc.Column{
+                 name: "array_of_text",
+                 type: :list,
+                 nullable: true,
+                 metadata: nil,
+                 data: [
+                   %Adbc.Column{
+                     name: "item",
+                     type: :string,
+                     nullable: true,
+                     metadata: nil,
+                     data: []
+                   },
+                   %Adbc.Column{
+                     name: "item",
+                     type: :string,
+                     nullable: true,
+                     metadata: nil,
+                     data: ["hello", "world"]
+                   },
+                   %Adbc.Column{
+                     name: "item",
+                     type: :string,
+                     nullable: true,
+                     metadata: nil,
+                     data: ["single"]
+                   }
+                 ]
+               }
+             ]
+           } = Adbc.Result.materialize(results)
+  end
 end

test/test_helper.exs

@@ -1,12 +1,18 @@
 Adbc.download_driver!(:sqlite)
 Adbc.download_driver!(:duckdb)
 
-exclude =
+pg_exclude =
   if System.find_executable("psql") do
     Adbc.download_driver!(:postgresql)
     []
   else
     [:postgresql]
   end
 
-ExUnit.start(exclude: exclude)
+windows_exclude =
+  case :os.type() do
+    {:win32, _} -> [:unix]
+    _ -> []
+  end
+
+ExUnit.start(exclude: pg_exclude ++ windows_exclude)