Update the tests.

Author: maleadt

test/core.jl

@@ -385,45 +385,51 @@ Context() do ctx
 
     @testset "array constants" begin
 
+    # from Julia values
     let
-        typ = LLVM.Int32Type(ctx)
         vec = Int32[1,2,3,4]
-        ca = ConstantArray(typ, vec)
-        @test convert(Int32, ConstantInt(ca[1]))::Int32 == Int32(1)
-        @test convert(Vector{Int32}, ca) == vec
+        ca = ConstantArray(vec, ctx)
+        @test size(vec) == size(ca)
+        @test length(vec) == length(ca)
+        @test ca[1] == ConstantInt(vec[1], ctx)
+        @test collect(ca) == ConstantInt.(vec, Ref(ctx))
     end
     let
-        typ = LLVM.FloatType(ctx)
         vec = Float32[1.1f0,2.2f0,3.3f0,4.4f0]
-        ca = ConstantArray(typ, vec)
-        @test convert(Float32, ConstantFP(ca[1]))::Float32 == 1.1f0
-        @test convert(Vector{Float32}, ca) == vec
+        ca = ConstantArray(vec, ctx)
+        @test size(vec) == size(ca)
+        @test length(vec) == length(ca)
+        @test ca[1] == ConstantFP(vec[1], ctx)
+        @test collect(ca) == ConstantFP.(vec, Ref(ctx))
     end
+
+    # multidimensional
     let
-        typ = LLVM.Int64Type(ctx)
-        vec = fill(5, 3, 4, 5, 6)
-        ca = ConstantArray(typ, vec)
-        @test length(ca) == size(vec, 1)
-        @test llvmtype(ca) == LLVM.ArrayType(LLVM.ArrayType(LLVM.ArrayType(LLVM.ArrayType(LLVM.Int64Type(ctx), 6), 5), 4), 3)
-        # NOTE: can't test content of the array because the API does not support reading from multidimensional arrays
+        vec = rand(Int, 2,3,4)
+        ca = ConstantArray(vec, ctx)
+        @test size(vec) == size(ca)
+        @test length(vec) == length(ca)
+        @test collect(ca) == ConstantInt.(vec, Ref(ctx))
     end
 
     end
 
     @testset "struct constants" begin
-    
+
+    # from Julia values
     let
         test_struct = TestStruct(true, -99, 1.5)
-        constant_struct = ConstantStruct(test_struct, ctx)
+        constant_struct = ConstantStruct(test_struct, ctx; anonymous=true)
         constant_struct_type = llvmtype(constant_struct)
-        
-        @test typeof(constant_struct_type) == LLVM.StructType
-        @test context(constant_struct_type) == ctx
+
+        @test constant_struct_type isa LLVM.StructType
+        @test context(constant_struct) == ctx
         @test !ispacked(constant_struct_type)
         @test !isopaque(constant_struct_type)
 
-        @test collect(elements(constant_struct_type)) == [LLVM.Int1Type(ctx), LLVM.Int64Type(ctx), LLVM.HalfType(ctx)]
-        
+        @test collect(elements(constant_struct_type)) ==
+            [LLVM.Int1Type(ctx), LLVM.Int64Type(ctx), LLVM.HalfType(ctx)]
+
         expected_operands = [
             ConstantInt(LLVM.Int1Type(ctx), Int(true)),
             ConstantInt(LLVM.Int64Type(ctx), -99),
@@ -432,13 +438,11 @@ Context() do ctx
         @test collect(operands(constant_struct)) == expected_operands
     end
     let
-        named_struct_type = LLVM.StructType("named_struct", ctx)
-        elements!(named_struct_type, [LLVM.Int1Type(ctx), LLVM.Int64Type(ctx), LLVM.HalfType(ctx)], true)
-
         test_struct = TestStruct(false, 52, -2.5)
-        constant_struct = ConstantStruct(test_struct, named_struct_type)
+        constant_struct = ConstantStruct(test_struct, ctx; anonymous=false)
+        constant_struct_type = llvmtype(constant_struct)
 
-        @test llvmtype(constant_struct) == named_struct_type
+        @test constant_struct_type isa LLVM.StructType
 
         expected_operands = [
             ConstantInt(LLVM.Int1Type(ctx), Int(false)),