Skip to content

Trampoline Evaluator #6167

Trampoline Evaluator

Trampoline Evaluator #6167

GitHub Actions / Test Report failed Dec 5, 2024 in 0s

84 passed, 1 failed and 0 skipped

Tests failed

❌ junit_tests.xml

85 tests were completed in 0ms with 84 passed, 1 failed and 0 skipped.

Test suite Passed Failed Skipped Time
HazelTests 84✅ 1❌ 0ms

❌ HazelTests

HazelTests.Elaboration
  ✅ Single integer
  ✅ Empty hole
  ✅ Free variable
  ✅ Let expression
  ✅ Inconsistent binary operation
  ✅ Consistent if statement
  ✅ An unapplied function
  ✅ Application of function on free variable
  ✅ Inconsistent case statement
  ✅ Let expression for a function
  ✅ Function application with a deferred argument
  ✅ Function application with a single remaining argument after deferral
  ✅ Function application with a deferral of a hole
HazelTests.Statics
  ✅ Function with unknown param
  ✅ Function with known param
  ✅ bifunction
  ✅ function application
  ✅ function deferral
HazelTests.Evaluator
  ✅ Integer literal
  ✅ Integer sum
  ✅ Function application
  ✅ Function deferral
  ❌ Deferral applied to hole
	Alcotest assertion failure
HazelTests.ListUtil
  ✅ rev_if with false
  ✅ rev_if with true
  ✅ dedup
  ✅ dedup_f
  ✅ group_by with constant function preserves list
  ✅ group_by groups into evens/odds
  ✅ range generates sequential integers [1,6)
  ✅ range defaults lower bound to 0
  ✅ range lo = hi is empty
  ✅ Invalid range raises error
  ✅ mk_frame creates a frame from the beginning
  ✅ mk_frame creates a frame from the end
  ✅ mk_frame raises when making a frame past the end
  ✅ mk_frame raises when making a frame before the beginning
  ✅ mk_frame makes a frame splitting the list
  ✅ mk_frame makes a frame splitting the list
  ✅ split with no found element returns the original list
  ✅ split with first found returns the head and tail
  ✅ splits on the middle element
  ✅ combine_opt
  ✅ is_empty with empty list
  ✅ is_empty with non-empty list
  ✅ flat_map with empty list
  ✅ flat_map with non-empty list
  ✅ flat_map with non-empty list and empty result
  ✅ join with empty list
  ✅ join with single element list
  ✅ join with multiple element list
  ✅ hd_opt with empty list
  ✅ hd_opt with non-empty list
  ✅ nth_opt with empty list
  ✅ nth_opt with non-empty list
  ✅ nth_opt with out of bounds index
  ✅ split_n_opt with empty list
  ✅ split_n_opt with non-empty list
  ✅ split_n_opt with out of bounds index
  ✅ split_n_opt with zero index
  ✅ split_n with empty list
  ✅ split_n with non-empty list
  ✅ split_n with out of bounds index
  ✅ split_n with zero index
  ✅ split_sublist_opt with empty list
  ✅ split_sublist_opt with non-empty list
  ✅ split_sublist_opt with out of bounds index
  ✅ split_sublist_opt with zero index
  ✅ split_sublist with empty list
  ✅ split_sublist with non-empty list
  ✅ split_sublist with out of bounds index
  ✅ split_sublist with zero index
  ✅ sublist with empty list
  ✅ sublist with non-empty list
  ✅ sublist with out of bounds index
HazelTests.MakeTerm
  ✅ Integer Literal
  ✅ Empty Hole
  ✅ Free Variable
  ✅ Parenthesized Expression
  ✅ Let Expression
  ✅ Function Application
  ✅ Named Function Definition
  ✅ Incomplete Function Definition
  ✅ Constructor
  ✅ Type Alias

Annotations

Check failure on line 0 in junit_tests.xml

See this annotation in the file changed.

@github-actions github-actions / Test Report

HazelTests ► HazelTests.Evaluator ► Deferral applied to hole

Failed test found in:
  junit_tests.xml
Error:
  Alcotest assertion failure
Raw output
Alcotest assertion failure
FAIL ?(_, _, 3)(1., true)

   Expected: `{ ids = <opaque>; copied = <opaque>;
  term =
  (Ap (Forward,
     { ids = <opaque>; copied = <opaque>;
       term =
       (Cast (
          { ids = <opaque>; copied = <opaque>;
            term =
            (Cast ({ ids = <opaque>; copied = <opaque>; term = EmptyHole },
               { ids = <opaque>; copied = <opaque>; term = (Unknown Internal)
                 },
               { ids = <opaque>; copied = <opaque>;
                 term =
                 (Arrow (
                    { ids = <opaque>; copied = <opaque>;
                      term = (Unknown Internal) },
                    { ids = <opaque>; copied = <opaque>;
                      term = (Unknown Internal) }
                    ))
                 }
               ))
            },
          { ids = <opaque>; copied = <opaque>;
            term =
            (Arrow (
               { ids = <opaque>; copied = <opaque>; term = (Unknown Internal)
                 },
               { ids = <opaque>; copied = <opaque>; term = (Unknown Internal)
                 }
               ))
            },
          { ids = <opaque>; copied = <opaque>;
            term =
            (Arrow (
               { ids = <opaque>; copied = <opaque>;
                 term =
                 (Prod
                    [{ ids = <opaque>; copied = <opaque>;
                       term = (Unknown Internal) };
                      { ids = <opaque>; copied = <opaque>;
                        term = (Unknown Internal) };
                      { ids = <opaque>; copied = <opaque>;
                        term = (Unknown Internal) }
                      ])
                 },
               { ids = <opaque>; copied = <opaque>; term = (Unknown Internal)
                 }
               ))
            }
          ))
       },
     { ids = <opaque>; copied = <opaque>;
       term =
       (Tuple
          [{ ids = <opaque>; copied = <opaque>;
             term =
             (Cast ({ ids = <opaque>; copied = <opaque>; term = (Float 1.) },
                { ids = <opaque>; copied = <opaque>; term = Float },
                { ids = <opaque>; copied = <opaque>;
                  term = (Unknown Internal) }
                ))
             };
            { ids = <opaque>; copied = <opaque>;
              term =
              (Cast (
                 { ids = <opaque>; copied = <opaque>; term = (Bool true) },
                 { ids = <opaque>; copied = <opaque>; term = Bool },
                 { ids = <opaque>; copied = <opaque>;
                   term = (Unknown Internal) }
                 ))
              };
            { ids = <opaque>; copied = <opaque>;
              term =
              (Cast ({ ids = <opaque>; copied = <opaque>; term = (Int 3) },
                 { ids = <opaque>; copied = <opaque>; term = Int },
                 { ids = <opaque>; copied = <opaque>;
                   term = (Unknown Internal) }
                 ))
              }
            ])
       }
     ))
  }'

   Received: `{ ids = <opaque>; copied = <opaque>;
  term =
  (Ap (Forward,
     { ids = <opaque>; copied = <opaque>;
       term =
       (Cast ({ ids = <opaque>; copied = <opaque>; term = EmptyHole },
          { ids = <opaque>; copied = <opaque>; term = (Unknown Internal) },
          { ids = <opaque>; copied = <opaque>;
            term =
            (Arrow (
               { ids = <opaque>; copied = <opaque>; term = (Unknown Internal)
                 },
               { ids = <opaque>; copied = <opaque>; term = (Unknown Internal)
                 }
               ))
            }
          ))
       },
     { ids = <opaque>; copied = <opaque>;
       term =
       (Cast (
          { ids = <opaque>; copied = <opaque>;
            term =
            (Tuple
               [{ ids = <opaque>; copied = <opaque>;
                  term =
                  (Cast (
                     { ids = <opaque>; copied = <opaque>; term = (Float 1.) },
                     { ids = <opaque>; copied = <opaque>; term = Float },
                     { ids = <opaque>; copied = <opaque>;
                       term = (Unknown Internal) }
                     ))
                  };
                 { ids = <opaque>; copied = <opaque>;
                   term =
                   (Cast (
                      { ids = <opaque>; copied = <opaque>; term = (Bool true)
                        },
                      { ids = <opaque>; copied = <opaque>; term = Bool },
                      { ids = <opaque>; copied = <opaque>;
                        term = (Unknown Internal) }
                      ))
                   };
                 { ids = <opaque>; copied = <opaque>;
                   term =
                   (Cast (
                      { ids = <opaque>; copied = <opaque>; term = (Int 3) },
                      { ids = <opaque>; copied = <opaque>; term = Int },
                      { ids = <opaque>; copied = <opaque>;
                        term = (Unknown Internal) }
                      ))
                   }
                 ])
            },
          { ids = <opaque>; copied = <opaque>;
            term =
            (Prod
               [{ ids = <opaque>; copied = <opaque>;
                  term = (Unknown Internal) };
                 { ids = <opaque>; copied = <opaque>;
                   term = (Unknown Internal) };
                 { ids = <opaque>; copied = <opaque>;
                   term = (Unknown Internal) }
                 ])
            },
          { ids = <opaque>; copied = <opaque>; term = (Unknown Internal) }))
       }
     ))
  }'