Pre-compiling Futhark functions...
Compilation complete.

╔═══════════════════════════════════════════════════════════════╗
║          FUTHARK-J BRIDGE TEST SUITE                         ║
╚═══════════════════════════════════════════════════════════════╝

═══ Compilation Tests ═══

  PASS: Compilation produces .so file
  PASS: Compiled file exists
  PASS: Cached compilation is fast

═══ Scalar Return Operations ═══

  PASS: Sum of 1-5
  PASS: Sum of single element
  PASS: Product of 1-5
  PASS: Min of 5 3 8 1 9
  PASS: Max of 5 3 8 1 9
  PASS: Average of 1-5

═══ Array Return Operations ═══

  PASS: Double 1 2 3 4 5
  PASS: Square 1 2 3 4 5
  PASS: Negate 1 2 3
  PASS: Cumsum 1 2 3 4 5
  PASS: Running max

═══ Edge Cases ═══

  PASS: Single element sum
  PASS: Single element double
  PASS: Negative numbers
  PASS: Zero in array
  PASS: Small values preserved

═══ Large Array Handling ═══

  PASS: Large array sum
  PASS: Large array double

═══ Type Mapping Tests ═══

  PASS: f64 maps to d
  PASS: f32 maps to f
  PASS: i64 maps to x
  PASS: i32 maps to i

═══ Metadata Parsing Tests ═══

  PASS: Parse entry name
  PASS: Detects scalar return
  PASS: Detects array return
  PASS: Parse f64 type
  PASS: Parse i32 type

═══ Multi-dimensional Array Tests ═══

  PASS: 2D transpose shape
  PASS: 2D transpose values
  PASS: Flatten 2D to 1D

═══ Different Input/Output Size Tests ═══

  PASS: Take first 3
  PASS: Drop first 5
  PASS: Replicate 2x
  PASS: Concat self

═══ Extended Parsing Tests ═══

  PASS: Parse 2D input rank
  PASS: Parse 2D output rank
  PASS: Parse flatten input rank
  PASS: Parse flatten output rank
  PASS: Extract basetype from []f64
  PASS: Extract basetype from [][]f64
  PASS: Extract basetype from f64
  PASS: Parse 3D input rank
  PASS: Parse 3D output rank
  PASS: Parse 3D->1D input rank
  PASS: Parse 3D->1D output rank

═══ 3D Array Tests ═══

  PASS: 3D identity shape
  PASS: 3D identity values
  PASS: 3D map shape
  PASS: 3D map values
  PASS: 3D->1D flatten
  PASS: 3D->2D flatten shape
  PASS: 3D->2D flatten values
  PASS: 3D sum

═══ J Native Verb Comparison Tests ═══

  PASS: Futhark sum = J +/
  PASS: Futhark product = J */
  PASS: Futhark double = J 2&*
  PASS: Futhark square = J *:
  PASS: Futhark cumsum = J +/\\
  PASS: Futhark transpose = J |:
  PASS: Futhark flatten = J ,
  PASS: Futhark id = J ]
  PASS: Futhark flat3d = J ,
  PASS: Futhark sum3d = J +/,

═══ Dynamic Helper Function Tests ═══

  PASS: 1D sig has _1d
  PASS: 1D sig has futhark_new
  PASS: 2D sig has _2d
  PASS: 2D sig has futhark_new
  PASS: 3D sig has _3d
  PASS: 3D sig has futhark_new
  PASS: i32 sig has _i32

═══ Dyadic (Two-Input) Function Tests ═══

  PASS: Dyadic dot product (1 2 3).(4 5 6)
  PASS: Dyadic dot = J +/@:*
  PASS: Dyadic mul = J *
  PASS: Dyadic add = J +
  PASS: Dyadic sub = J -
  PASS: Dyadic max = J >.
  PASS: Dyadic min = J <.
  PASS: Single input count
  PASS: Double input count

═══ Scalar Input Tests (v1.6.0) ═══

  PASS: Factors of 12
  PASS: Factors of 100
  PASS: Factors of 17 (prime)
  PASS: Factors of 1 (empty)
  PASS: Fib 0
  PASS: Fib 1
  PASS: Fib 10
  PASS: Fib 20
  PASS: Scalar input rank
  PASS: Scalar input dtype
  PASS: Scalar in/out input rank
  PASS: Scalar in/out output rank
  PASS: Parse return type no space
  PASS: Parse output rank no space

═══ Fixed-Size Array Tests (v1.7.0) ═══

  PASS: Fixed-size output rank
  PASS: Fixed-size output dtype
  PASS: Fixed-size input rank
  PASS: Extract basetype from [][3]i64
  PASS: Extract basetype from [][32]i64
  PASS: Extract basetype from [5][3]f32
  PASS: Bracket count [][3]i64
  PASS: Bracket count [][32]i64
  PASS: Bracket count [5][3][7]f64
  PASS: 1D->2D fixed shape
  PASS: 1D->2D fixed row 1
  PASS: 1D->2D fixed row 5

═══ Helper Function Parsing Tests (v1.7.0) ═══

  PASS: Def helper: input type
  PASS: Def helper: input rank
  PASS: Def helper: output type
  PASS: Def helper: output rank
  PASS: Complex def: input rank
  PASS: Complex def: output type
  PASS: Complex def: output rank
  PASS: Batch factorize: input type
  PASS: Batch factorize: input rank
  PASS: Batch factorize: output type
  PASS: Batch factorize: output rank
  PASS: Batch factor shape
  PASS: Batch factor row 1 (12=2*2*3)
  PASS: Batch factor row 2 (100=2*2*5*5)
  PASS: Batch factor row 3 (30=2*3*5)

═══════════════════════════════════════════════════════════════

  Tests run:    123
  Tests passed: 123
  Tests failed: 0

  ALL TESTS PASSED!

═══════════════════════════════════════════════════════════════