Skip to content

first working version of redundancy checking - currently only prints … #6634

first working version of redundancy checking - currently only prints …

first working version of redundancy checking - currently only prints … #6634

GitHub Actions / Test Report failed Feb 1, 2025 in 0s

170 passed, 3 failed and 5 skipped

Tests failed

❌ junit_tests.xml

178 tests were completed in 0ms with 170 passed, 3 failed and 5 skipped.

Test suite Passed Failed Skipped Time
HazelTests 170✅ 3❌ 5⚪ 0ms

❌ HazelTests

HazelTests.ExpToSegment
  ✅ Empty Ids on ExpToSegment constructor
  ✅ Match statement
  ✅ Deferred application
  ✅ Test
  ✅ Filter
  ✅ Right associativity
HazelTests.MenhirParser
  ✅ Integer Literal
  ✅ Fun
  ✅ String Literal
  ✅ Bool Literal
  ✅ Empty Hole
  ✅ Var
  ✅ Parens
  ✅ BinOp
  ✅ Let
  ✅ Tuple
  ✅ Match
  ✅ If
  ✅ Deferred Ap
  ✅ Cons
  ✅ ListLit
  ✅ Unit
  ✅ Constructor
  ✅ Constructor cast
  ✅ Constructor of specific sum type
  ✅ Constructor with Type Variable
  ✅ Type Variable
  ✅ Type Alias
  ✅ Test
  ✅ Filter
  ✅ List Concat
  ✅ times and divide precendence
  ✅ plus and minus precendence
  ✅ Integer Ops
  ✅ Float
  ✅ Float Ops
  ✅ Let binding with type ascription
  ✅ named_function
  ✅ basic sum type
  ✅ Empty Type Hole
  ✅ Pattern with type ascription
  ✅ Type Hole in arrow cast
  ✅ multiargument function
  ✅ partial sum type
  ✅ Function with type variable
  ✅ Sequence addition precedence
  ✅ And app precedence
  ✅ Negation precedence with multiplication
  ✅ Concatenation association
  ✅ and less than precedence
  ✅ Altered Documentation Buffer: Basic Reference
  ✅ Altered Documentation Buffer: Projectors
  ✅ Altered Documentation Buffer: Types & Static Errors
  ✅ Altered Documentation Buffer: adt dynamics
  ✅ Altered Documentation Buffer: Polymorphism
  ⚪ Prefixed keyword parses
  ⚪ Sum type messed up in make term
  ⚪ List concat and typap
  ⚪ Sum in product in typeap
  ⚪ Non-unique constructors currently throws in equality
  ✅ Menhir and maketerm are equivalent
  ✅ Menhir through ExpToSegment and back
HazelTests.StringUtil
  ✅ empty string splits
  ✅ split on empty string
  ✅ split with no matches
  ✅ split with one match
  ✅ split with multiple matches
  ✅ split with empty inbetweens
  ✅ regexp special character in separator
HazelTests.Statics
  ✅ Function with unknown param
  ✅ Function with known param
  ❌ bifunction
	Alcotest assertion failure
  ✅ function application
  ✅ function deferral
HazelTests.Evaluator
  ✅ Integer literal
  ✅ Integer sum
  ✅ Function application
  ✅ Function deferral
  ✅ Deferral applied to hole
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
HazelTests.Elaboration tests
  ✅ Single integer
  ✅ Empty hole
  ✅ Free variable
  ❌ Let expression
	Alcotest assertion failure
  ✅ 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.Menhir elaboration tests
  ✅ Filter test (menhir)
  ✅ Test failed (menhir)
  ✅ Built-in function (menhir)
  ✅ Dynamic error hole (menhir)
  ✅ Constructor test (menhir)
  ✅ Failed cast test (menhir)
  ✅ Type ap test (menhir)
  ❌ Let expression for a tuple (menhir)
	Alcotest assertion failure
  ✅ Single integer (menhir)
  ✅ Let expression for a function (menhir)
  ✅ Empty hole (menhir)
  ✅ Free var (menhir)
  ✅ Bin op (menhir)
  ✅ Inconsistent case (menhir)
  ✅ ap fun (menhir)
  ✅ Consistent if (menhir)
  ✅ Undefined test (menhir)
  ✅ List exp (menhir)
  ✅ Invalid test (menhir)
  ✅ Type alias test (menhir)
  ✅ List concat test (menhir)
  ✅ Unary operation test (menhir)
  ✅ Sequence test (menhir)
  ✅ FixF test (menhir)

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.Statics ► bifunction

Failed test found in:
  junit_tests.xml
Error:
  Alcotest assertion failure
Raw output
Alcotest assertion failure
FAIL x : Int, y: Int => x + y

   Expected: `Some
                { ids = <opaque>; copied = <opaque>;
  term =
  (Arrow (
     { ids = <opaque>; copied = <opaque>;
       term =
       (Prod
          [{ ids = <opaque>; copied = <opaque>; term = Int };
            { ids = <opaque>; copied = <opaque>; term = Int }])
       },
     { ids = <opaque>; copied = <opaque>; term = Int }))
  }'

   Received: `Some
                { ids = <opaque>; copied = <opaque>; term = (Unknown Internal) }'

Check failure on line 0 in junit_tests.xml

See this annotation in the file changed.

@github-actions github-actions / Test Report

HazelTests ► HazelTests.Elaboration tests ► Let expression

Failed test found in:
  junit_tests.xml
Error:
  Alcotest assertion failure
Raw output
Alcotest assertion failure
FAIL Let expression for tuple (a, b)

   Expected: `{ ids = <opaque>; copied = <opaque>;
  term =
  (Let (
     { ids = <opaque>; copied = <opaque>;
       term =
       (Tuple
          [{ ids = <opaque>; copied = <opaque>; term = (Var "a") };
            { ids = <opaque>; copied = <opaque>; term = (Var "b") }])
       },
     { ids = <opaque>; copied = <opaque>;
       term =
       (Tuple
          [{ ids = <opaque>; copied = <opaque>; term = (Int 4) };
            { ids = <opaque>; copied = <opaque>; term = (Int 6) }])
       },
     { ids = <opaque>; copied = <opaque>;
       term =
       (BinOp ((Int Minus),
          { ids = <opaque>; copied = <opaque>; term = (Var "a") },
          { ids = <opaque>; copied = <opaque>; term = (Var "b") }))
       }
     ))
  }'

   Received: `{ ids = <opaque>; copied = <opaque>;
  term =
  (Cast (
     { ids = <opaque>; copied = <opaque>;
       term =
       (Let (
          { ids = <opaque>; copied = <opaque>;
            term =
            (Tuple
               [{ ids = <opaque>; copied = <opaque>; term = (Var "a") };
                 { ids = <opaque>; copied = <opaque>; term = (Var "b") }])
            },
          { ids = <opaque>; copied = <opaque>;
            term =
            (Tuple
               [{ ids = <opaque>; copied = <opaque>; term = (Int 4) };
                 { ids = <opaque>; copied = <opaque>; term = (Int 6) }])
            },
          { ids = <opaque>; copied = <opaque>;
            term =
            (BinOp ((Int Minus),
               { ids = <opaque>; copied = <opaque>; term = (Var "a") },
               { ids = <opaque>; copied = <opaque>; term = (Var "b") }))
            }
          ))
       },
     { ids = <opaque>; copied = <opaque>; term = Int },
     { ids = <opaque>; copied = <opaque>; term = (Unknown Internal) }))
  }'

Check failure on line 0 in junit_tests.xml

See this annotation in the file changed.

@github-actions github-actions / Test Report

HazelTests ► HazelTests.Menhir elaboration tests ► Let expression for a tuple (menhir)

Failed test found in:
  junit_tests.xml
Error:
  Alcotest assertion failure
Raw output
Alcotest assertion failure
FAIL Let expression for tuple (a, b) (menhir)

   Expected: `{ ids = <opaque>; copied = <opaque>;
  term =
  (Let (
     { ids = <opaque>; copied = <opaque>;
       term =
       (Parens
          { ids = <opaque>; copied = <opaque>;
            term =
            (Tuple
               [{ ids = <opaque>; copied = <opaque>; term = (Var "a") };
                 { ids = <opaque>; copied = <opaque>; term = (Var "b") }])
            })
       },
     { ids = <opaque>; copied = <opaque>;
       term =
       (Parens
          { ids = <opaque>; copied = <opaque>;
            term =
            (Tuple
               [{ ids = <opaque>; copied = <opaque>; term = (Int 4) };
                 { ids = <opaque>; copied = <opaque>; term = (Int 6) }])
            })
       },
     { ids = <opaque>; copied = <opaque>;
       term =
       (BinOp ((Int Minus),
          { ids = <opaque>; copied = <opaque>; term = (Var "a") },
          { ids = <opaque>; copied = <opaque>; term = (Var "b") }))
       }
     ))
  }'

   Received: `{ ids = <opaque>; copied = <opaque>;
  term =
  (Cast (
     { ids = <opaque>; copied = <opaque>;
       term =
       (Let (
          { ids = <opaque>; copied = <opaque>;
            term =
            (Tuple
               [{ ids = <opaque>; copied = <opaque>; term = (Var "a") };
                 { ids = <opaque>; copied = <opaque>; term = (Var "b") }])
            },
          { ids = <opaque>; copied = <opaque>;
            term =
            (Tuple
               [{ ids = <opaque>; copied = <opaque>; term = (Int 4) };
                 { ids = <opaque>; copied = <opaque>; term = (Int 6) }])
            },
          { ids = <opaque>; copied = <opaque>;
            term =
            (BinOp ((Int Minus),
               { ids = <opaque>; copied = <opaque>; term = (Var "a") },
               { ids = <opaque>; copied = <opaque>; term = (Var "b") }))
            }
          ))
       },
     { ids = <opaque>; copied = <opaque>; term = Int },
     { ids = <opaque>; copied = <opaque>; term = (Unknown Internal) }))
  }'