Logs for the as2js 0.1.0 tests

Tests started on Sat Nov 22 06:03:14 PST 2014 and finished on Sat Nov 22 07:12:59 PST 2014

Start running the tests on Sat Nov 22 06:05:00 PST 2014

test_as2js[25521]: version 0.1.0, seed is 1416665100
As2JsCompilerUnitTests::test_compiler_invalid_nodes : OK
As2JsCompilerUnitTests::test_compiler_class
  -- working on "empty class" ................................ OK
 : OK
As2JsDBUnitTests::test_match : OK
As2JsDBUnitTests::test_element : OK
As2JsDBUnitTests::test_package : OK
As2JsDBUnitTests::test_database : OK
As2JsFloat64UnitTests::test_float64 : OK
As2JsFloat64UnitTests::test_special_numbers : OK
As2JsFloat64UnitTests::test_nearly_equal : OK
As2JsInt64UnitTests::test_int64 : OK
As2JsJSONUnitTests::test_basic_values : OK
As2JsJSONUnitTests::test_array_value : OK
As2JsJSONUnitTests::test_object_value : OK
As2JsJSONUnitTests::test_json : OK
As2JsJSONUnitTests::test_json_with_positive_numbers : OK
As2JsJSONUnitTests::test_error : OK
As2JsLexerUnitTests::test_invalid_pointers : OK
As2JsLexerUnitTests::test_tokens................................... : OK
As2JsLexerUnitTests::test_valid_strings....................... : OK
As2JsLexerUnitTests::test_invalid_strings...................................... : OK
As2JsLexerUnitTests::test_invalid_numbers : OK
As2JsLexerUnitTests::test_identifiers....................... : OK
As2JsLexerUnitTests::test_invalid_input : OK
As2JsLexerUnitTests::test_mixed_tokens : OK
As2JsMessageUnitTests::test_message[0]....................................................................................[1]....................................................................................[2]....................................................................................[3]....................................................................................[4]....................................................................................[5]....................................................................................[6].................................................................................... : OK
As2JsMessageUnitTests::test_operator : OK
As2JsNodeUnitTests::test_type : OK
As2JsNodeUnitTests::test_compare : OK
As2JsNodeUnitTests::test_conversions : OK
As2JsNodeUnitTests::test_tree : OK
As2JsNodeUnitTests::test_param : OK
As2JsNodeUnitTests::test_position : OK
As2JsNodeUnitTests::test_links : OK
As2JsNodeUnitTests::test_variables : OK
As2JsNodeUnitTests::test_labels : OK
As2JsNodeUnitTests::test_attributes : OK
As2JsNodeUnitTests::test_display_all_types : OK
As2JsNodeUnitTests::test_display_unicode_string : OK
As2JsNodeUnitTests::test_display_flags : OK
As2JsNodeUnitTests::test_display_attributes : OK
As2JsNodeUnitTests::test_display_tree : OK
As2JsOptimizerUnitTests::test_optimizer_invalid_nodesOptimize with: 'a+b' when 'a' and 'b' are numbers -> 'sum(a,b)'
 : OK
As2JsOptimizerUnitTests::test_optimizer_additive
  -- working on "+a -> a, with an integer" ...Optimize with: '+a' when 'a' is a literal -> 'a'
 OK
  -- working on "+a -> a, with a float" ...Optimize with: '+a' when 'a' is a literal -> 'a'
 OK
  -- working on "+a -> a, with a undefined" ...Optimize with: '+a' when 'a' is a literal -> 'a'
 OK
  -- working on "+a -> a, with a null" ...Optimize with: '+a' when 'a' is a literal -> 'a'
 OK
  -- working on "+a -> a, with an empty string" ...Optimize with: '+a' when 'a' is a literal -> 'a'
 OK
  -- working on "+a -> a, with a string not representing a number" ...Optimize with: '+a' when 'a' is a literal -> 'a'
 OK
  -- working on "+a -> a, with a string representing an integer" ...Optimize with: '+a' when 'a' is a literal -> 'a'
 OK
  -- working on "+a -> a, with a string representing a float" ...Optimize with: '+a' when 'a' is a literal -> 'a'
 OK
  -- working on "+a -> a, with true" ...Optimize with: '+a' when 'a' is a literal -> 'a'
 OK
  -- working on "+a -> a, with false" ...Optimize with: '+a' when 'a' is a literal -> 'a'
 OK
  -- working on "+a -> a, with an object" ...Optimize with: '+a' when 'a' is anything -> 'a'
 OK
  -- working on "-a -> a, with an integer" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
 OK
  -- working on "-a -> a, with a float" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
 OK
  -- working on "-a -> a, with null" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
 OK
  -- working on "-a -> a, with undefined" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
 OK
  -- working on "-a -> a, with an empty string" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
 OK
  -- working on "-a -> a, with a string not representing a number" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
 OK
  -- working on "-a -> a, with a string representing an integer" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
 OK
  -- working on "-a -> a, with a string representing a float" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
 OK
  -- working on "-a -> a, with true" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
 OK
  -- working on "-a -> a, with false" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
 OK
  -- working on "3 - a -> 3 - a, with integers" ... OK
  -- working on "a + 3 -> sum(a, 3), with integers" ... OK
  -- working on "a + 3.5 -> sum(a, 3.5), with floats" ... OK
  -- working on "3.5 - a -> 3.5 - a, with floats" ... OK
  -- working on "a + NaN -> sum(a, NaN), with floats" ... OK
  -- working on "a + b -> sum(a, b), with integers" ...Optimize with: 'a+b' when 'a' and 'b' are numbers -> 'sum(a,b)'
 OK
  -- working on "a + b -> sum(a, b), with integer/float" ...Optimize with: 'a+b' when 'a' and 'b' are numbers -> 'sum(a,b)'
 OK
  -- working on "a + b -> sum(a, b), with float/integer" ...Optimize with: 'a+b' when 'a' and 'b' are numbers -> 'sum(a,b)'
 OK
  -- working on "a + b -> sum(a, b), with floats" ...Optimize with: 'a+b' when 'a' and 'b' are numbers -> 'sum(a,b)'
 OK
  -- working on "a - b -> subtract(a, b), with integers" ...Optimize with: 'a-b' when 'a' and 'b' are numbers -> 'subtract(a,b)'
 OK
  -- working on "a - b -> subtract(a, b), with integer/float" ...Optimize with: 'a-b' when 'a' and 'b' are numbers -> 'subtract(a,b)'
 OK
  -- working on "a - b -> subtract(a, b), with float/integer" ...Optimize with: 'a-b' when 'a' and 'b' are numbers -> 'subtract(a,b)'
 OK
  -- working on "a - b -> subtract(a, b), with floats" ...Optimize with: 'a-b' when 'a' and 'b' are numbers -> 'subtract(a,b)'
 OK
  -- working on "0 - a -> -a, with integer" ...Optimize with: '0-a' or '0.0-a' -> '-a'
 OK
  -- working on "0.0 - a -> -a, with float" ...Optimize with: '0-a' or '0.0-a' -> '-a'
 OK
  -- working on "a + b -> concatenate(a, b), with strings" ...Optimize with: 'a+b' when 'a' is a string and 'b' any literal -> 'concatenate(a,to_string(b))'
 OK
  -- working on "a + b -> concatenate(a, b), with string/true" ...Optimize with: 'a+b' when 'a' is a string and 'b' any literal -> 'concatenate(a,to_string(b))'
 OK
  -- working on "a + b -> concatenate(a, b), with true/string" ...Optimize with: 'a+b' when 'a' is any literal and 'b' is a string -> 'concatenate(to_string(a),b)'
 OK
  -- working on "a + b -> concatenate(a, b), with string/false" ...Optimize with: 'a+b' when 'a' is a string and 'b' any literal -> 'concatenate(a,to_string(b))'
 OK
  -- working on "a + b -> concatenate(a, b), with false/string" ...Optimize with: 'a+b' when 'a' is any literal and 'b' is a string -> 'concatenate(to_string(a),b)'
 OK
  -- working on "a + b -> concatenate(a, b), with string/null" ...Optimize with: 'a+b' when 'a' is a string and 'b' any literal -> 'concatenate(a,to_string(b))'
 OK
  -- working on "a + b -> concatenate(a, b), with null/string" ...Optimize with: 'a+b' when 'a' is any literal and 'b' is a string -> 'concatenate(to_string(a),b)'
 OK
  -- working on "a + b -> concatenate(a, b), with string/undefined" ...Optimize with: 'a+b' when 'a' is a string and 'b' any literal -> 'concatenate(a,to_string(b))'
 OK
  -- working on "a + b -> concatenate(a, b), with undefined/string" ...Optimize with: 'a+b' when 'a' is any literal and 'b' is a string -> 'concatenate(to_string(a),b)'
 OK
  -- working on "a + b -> concatenate(a, b), with string/integer" ...Optimize with: 'a+b' when 'a' is a string and 'b' any literal -> 'concatenate(a,to_string(b))'
 OK
  -- working on "a + b -> concatenate(a, b), with integer/string" ...Optimize with: 'a+b' when 'a' is any literal and 'b' is a string -> 'concatenate(to_string(a),b)'
 OK
  -- working on "a + b -> concatenate(a, b), with string/float" ...Optimize with: 'a+b' when 'a' is a string and 'b' any literal -> 'concatenate(a,to_string(b))'
 OK
  -- working on "a + b -> concatenate(a, b), with float/string" ...Optimize with: 'a+b' when 'a' is any literal and 'b' is a string -> 'concatenate(to_string(a),b)'
 OK
  -- working on """ - a -> "" - a" ... OK
 : OK
As2JsOptimizerUnitTests::test_optimizer_assignments
  -- working on "a = a; -> a" ...Optimize with: 'a = a;' -> 'a;'
 OK
  -- working on "a = b; -> a = b;" ... OK
  -- working on "a -= NaN; -> a = NaN;" ...Optimize with: 'a = NaN;' -> 'a = NaN;'
 OK
  -- working on "a *= NaN; -> a = NaN;" ...Optimize with: 'a = NaN;' -> 'a = NaN;'
 OK
  -- working on "a /= NaN; -> a = NaN;" ...Optimize with: 'a = NaN;' -> 'a = NaN;'
 OK
  -- working on "a %= NaN; -> a = NaN;" ...Optimize with: 'a = NaN;' -> 'a = NaN;'
 OK
  -- working on "a **= NaN; -> a = NaN;" ...Optimize with: 'a = NaN;' -> 'a = NaN;'
 OK
  -- working on "a  a;" ...Optimize with: 'a = NaN;' -> 'a;'
 OK
  -- working on "a >?= NaN; -> a;" ...Optimize with: 'a = NaN;' -> 'a;'
 OK
  -- working on "a &= NaN; -> a = 0;" ...Optimize with: 'a = NaN;' where  is a bitwise operator -> 'a = 0;'
 OK
  -- working on "a |= NaN; -> a = 0;" ...Optimize with: 'a = NaN;' where  is a bitwise operator -> 'a = 0;'
 OK
  -- working on "a ^= NaN; -> a = 0;" ...Optimize with: 'a = NaN;' where  is a bitwise operator -> 'a = 0;'
 OK
  -- working on "a <<= NaN; -> a = 0;" ...Optimize with: 'a = NaN;' where  is a bitwise operator -> 'a = 0;'
 OK
  -- working on "a >>= NaN; -> a = 0;" ...Optimize with: 'a = NaN;' where  is a bitwise operator -> 'a = 0;'
 OK
  -- working on "a >>>= NaN; -> a = 0;" ...Optimize with: 'a = NaN;' where  is a bitwise operator -> 'a = 0;'
 OK
  -- working on "a <%= NaN; -> a = 0;" ...Optimize with: 'a = NaN;' where  is a bitwise operator -> 'a = 0;'
 OK
  -- working on "a >%= NaN; -> a = 0;" ...Optimize with: 'a = NaN;' where  is a bitwise operator -> 'a = 0;'
 OK
 : OK
As2JsOptimizerUnitTests::test_optimizer_bitwise
  -- working on "0xAFC3 & 0x5355 -> 0x341" ...Optimize with: a & b, where a and b are numbers -> and(a, b)
 OK
  -- working on "0xAFC3 & NaN -> 0" ...Optimize with: a & b, where a and b are numbers -> and(a, b)
 OK
  -- working on "0xAFC3 | 0x5355 -> 0xFFD7" ...Optimize with: a | b, where a and b are numbers -> or(a, b)
 OK
  -- working on "0xAFC3 | 0x5355 -> 0x5355" ...Optimize with: a | b, where a and b are numbers -> or(a, b)
 OK
  -- working on "0xAFC3 ^ 0x5355 -> 0xFC96" ...Optimize with: a ^ b, where a and b are numbers -> xor(a, b)
 OK
  -- working on "0xAFC3 ^ NaN -> 0xAFC3" ...Optimize with: a ^ b, where a and b are numbers -> xor(a, b)
 OK
  -- working on "NaN ^ 0xAFC3 -> 0xAFC3" ...Optimize with: a ^ b, where a and b are numbers -> xor(a, b)
 OK
  -- working on "number << number -> number" ...Optimize with: a << b, where a and b are numbers -> shift_left(a, b)
 OK
  -- working on "number << number -> number" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: a << b, where a and b are numbers -> shift_left(a, b)
 OK
  -- working on "number << number -> number" ...Optimize with: 'a+b' when 'a' and 'b' are numbers -> 'sum(a,b)'
Optimize with: a << b, where a and b are numbers -> shift_left(a, b)
 OK
  -- working on "number >> number -> number" ...Optimize with: a >> b, where a and b are numbers -> shift_right(a, b)
 OK
  -- working on "number >> number -> number" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: a >> b, where a and b are numbers -> shift_right(a, b)
 OK
  -- working on "number >> number -> number" ...Optimize with: 'a+b' when 'a' and 'b' are numbers -> 'sum(a,b)'
Optimize with: a >> b, where a and b are numbers -> shift_right(a, b)
 OK
  -- working on "number >> number -> number" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: a >> b, where a and b are numbers -> shift_right(a, b)
 OK
  -- working on "number >>> number -> number" ...Optimize with: a >>> b, where a and b are numbers -> shift_right_unsigned(a, b)
 OK
  -- working on "number >>> number -> number" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: a >>> b, where a and b are numbers -> shift_right_unsigned(a, b)
 OK
  -- working on "number >>> number -> number" ...Optimize with: 'a+b' when 'a' and 'b' are numbers -> 'sum(a,b)'
Optimize with: a >>> b, where a and b are numbers -> shift_right_unsigned(a, b)
 OK
  -- working on "number >>> number -> number" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: a >>> b, where a and b are numbers -> shift_right_unsigned(a, b)
 OK
  -- working on "number <% number -> number" ...Optimize with: a <% b, where a and b are numbers -> rotate_left(a, b)
 OK
  -- working on "number <% number -> number" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: a <% b, where a and b are numbers -> rotate_left(a, b)
 OK
  -- working on "number <% number -> number" ...Optimize with: 'a+b' when 'a' and 'b' are numbers -> 'sum(a,b)'
Optimize with: a <% b, where a and b are numbers -> rotate_left(a, b)
 OK
  -- working on "number >% number -> number" ...Optimize with: a >% b, where a and b are numbers -> rotate_right(a, b)
 OK
  -- working on "number >% number -> number" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: a >% b, where a and b are numbers -> rotate_right(a, b)
 OK
  -- working on "number >% number -> number" ...Optimize with: 'a+b' when 'a' and 'b' are numbers -> 'sum(a,b)'
Optimize with: a >% b, where a and b are numbers -> rotate_right(a, b)
 OK
  -- working on "-1000 >% 4 -> 0x8FFFFFC1" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: a >% b, where a and b are numbers -> rotate_right(a, b)
 OK
  -- working on "0xF195BAFC3 >% NaN -> 0x195BAFC3" ...Optimize with: a >% b, where a and b are numbers -> rotate_right(a, b)
 OK
  -- working on "0xF195BAFC3 >% -NaN -> 0x195BAFC3" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: a >% b, where a and b are numbers -> rotate_right(a, b)
 OK
  -- working on "0xF195BAFC3 >% Infinity -> 0x195BAFC3" ...Optimize with: a >% b, where a and b are numbers -> rotate_right(a, b)
 OK
  -- working on "0xF195BAFC3 >% -Infinity -> 0x195BAFC3" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: a >% b, where a and b are numbers -> rotate_right(a, b)
 OK
  -- working on "~~~(a + b) -> ~(a +b)" ...Optimize with: ~~~a -> ~a
 OK
  -- working on "~0xF195BAFC3 -> 0x0E6A4503C" ...Optimize with: ~a, where a is a literal -> bitwise_not(a)
 OK
  -- working on "~0.0 -> 0xFFFFFFFF" ...Optimize with: ~a, where a is a literal -> bitwise_not(a)
 OK
  -- working on "!~(a + b) -> !~(a +b)" ... OK
  -- working on "a & 0xFFFFFFFF -> a | 0" ...Optimize with: a & 0xFFFFFFFF -> a | 0
 OK
  -- working on "0xFFFFFFFF & a -> 0 | a" ...Optimize with: '0xFFFFFFFF & a' -> '0 | a'
 OK
  -- working on "-1 & a -> 0 | a" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: '0xFFFFFFFF & a' -> '0 | a'
 OK
  -- working on "-2 & a -> 0 | a" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
 OK
  -- working on "-1.0 & a -> 0 | a" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: '0xFFFFFFFF & a' -> '0 | a'
 OK
  -- working on "-2.0 & a -> 0 | a" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
 OK
  -- working on "a ^ 0xFFFFFFFF -> ~a" ...Optimize with: a ^ 0xFFFFFFFF -> ~a
 OK
  -- working on "-a ^ 0xFFFFFFFF -> ~-a" ...Optimize with: a ^ 0xFFFFFFFF -> ~a
 OK
  -- working on "-1 ^ a -> ~a" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: 0xFFFFFFFF ^ a -> ~a
 OK
  -- working on "-1.0 ^ a -> ~a" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: 0xFFFFFFFF ^ a -> ~a
 OK
 : OK
As2JsOptimizerUnitTests::test_optimizer_compare
  -- working on ""ABC" <=> "XYZ" -> -1" ...Optimize with: 'a <=> b' when 'a' and 'b' are literals -> 'compare(a, b)'
 OK
  -- working on ""XYZ" <=> "ABC" -> 1" ...Optimize with: 'a <=> b' when 'a' and 'b' are literals -> 'compare(a, b)'
 OK
  -- working on ""ABC" <=> "ABC" -> 0" ...Optimize with: 'a <=> b' when 'a' and 'b' are literals -> 'compare(a, b)'
 OK
  -- working on "33 <=> 44 -> -1" ...Optimize with: 'a <=> b' when 'a' and 'b' are literals -> 'compare(a, b)'
 OK
  -- working on "44 <=> 33 -> 1" ...Optimize with: 'a <=> b' when 'a' and 'b' are literals -> 'compare(a, b)'
 OK
  -- working on "33 <=> 33 -> 0" ...Optimize with: 'a <=> b' when 'a' and 'b' are literals -> 'compare(a, b)'
 OK
  -- working on "3.3 <=> 4.4 -> -1" ...Optimize with: 'a <=> b' when 'a' and 'b' are literals -> 'compare(a, b)'
 OK
  -- working on "4.4 <=> 3.3 -> 1" ...Optimize with: 'a <=> b' when 'a' and 'b' are literals -> 'compare(a, b)'
 OK
  -- working on "3.3 <=> 3.3 -> 0" ...Optimize with: 'a <=> b' when 'a' and 'b' are literals -> 'compare(a, b)'
 OK
  -- working on ""3.3" <=> 4.4 -> -1" ...Optimize with: 'a <=> b' when 'a' and 'b' are literals -> 'compare(a, b)'
 OK
  -- working on ""4.4" <=> 3.3 -> 1" ...Optimize with: 'a <=> b' when 'a' and 'b' are literals -> 'compare(a, b)'
 OK
  -- working on ""3.3" <=> 3.3 -> 0" ...Optimize with: 'a <=> b' when 'a' and 'b' are literals -> 'compare(a, b)'
 OK
  -- working on "3.3 <=> "4.4" -> -1" ...Optimize with: 'a <=> b' when 'a' and 'b' are literals -> 'compare(a, b)'
 OK
  -- working on "4.4 <=> "3.3" -> 1" ...Optimize with: 'a <=> b' when 'a' and 'b' are literals -> 'compare(a, b)'
 OK
  -- working on "3.3 <=> "3.3" -> 0" ...Optimize with: 'a <=> b' when 'a' and 'b' are literals -> 'compare(a, b)'
 OK
  -- working on "-Infinity <=> +Infinity -> -1" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: 'a <=> b' when 'a' and 'b' are literals -> 'compare(a, b)'
 OK
  -- working on "+Infinity <=> -Infinity -> 1" ...Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: 'a <=> b' when 'a' and 'b' are literals -> 'compare(a, b)'
 OK
  -- working on "+Infinity <=> +Infinity -> 0" ...Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: 'a <=> b' when 'a' and 'b' are literals -> 'compare(a, b)'
 OK
  -- working on "-Infinity <=> -Infinity -> 0" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: 'a <=> b' when 'a' and 'b' are literals -> 'compare(a, b)'
 OK
  -- working on "33 <=> "XYZ" -> undefined" ...Optimize with: 'a <=> b' when 'a' and 'b' are literals -> 'compare(a, b)'
 OK
  -- working on ""ABC" <=> 4.4 -> undefined" ...Optimize with: 'a <=> b' when 'a' and 'b' are literals -> 'compare(a, b)'
 OK
  -- working on "+Infinity <=> 'not a number' -> undefined" ...Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: 'a <=> b' when 'a' and 'b' are literals -> 'compare(a, b)'
 OK
  -- working on "'not a number' <=> -Infinity -> undefined" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: 'a <=> b' when 'a' and 'b' are literals -> 'compare(a, b)'
 OK
  -- working on "null <=> undefined -> 0" ...Optimize with: 'a <=> b' when 'a' and 'b' are literals -> 'compare(a, b)'
 OK
  -- working on "null <=> 0 -> 0" ...Optimize with: 'a <=> b' when 'a' and 'b' are literals -> 'compare(a, b)'
 OK
  -- working on "0.0 <=> undefined -> undefined" ...Optimize with: 'a <=> b' when 'a' and 'b' are literals -> 'compare(a, b)'
 OK
 : OK
As2JsOptimizerUnitTests::test_optimizer_conditional
  -- working on "true ? a : b -> a" ...Optimize with: 'true ? a : b' -> 'a'
 OK
  -- working on "false ? a : b -> b" ...Optimize with: 'false ? a : b' -> 'b'
 OK
  -- working on "a  a" ...Optimize with: 'a  'min(a, b)'
 OK
  -- working on "NaN  a" ...Optimize with: 'a  'min(a, b)'
 OK
  -- working on "a  a" ...Optimize with: 'a  'min(a, b)'
 OK
  -- working on "a >? b -> a" ...Optimize with: 'a >? b' where a and b are literals -> 'max(a, b)'
 OK
  -- working on "NaN >? a -> a" ...Optimize with: 'a >? b' where a and b are literals -> 'max(a, b)'
 OK
  -- working on "a >? NaN -> a" ...Optimize with: 'a >? b' where a and b are literals -> 'max(a, b)'
 OK
 : OK
As2JsOptimizerUnitTests::test_optimizer_equality
  -- working on ""ABC" == "XYZ" -> false" ...Optimize with: 'a == b', with a and b as literals -> equal(a, b)
 OK
  -- working on ""XYZ" == "ABC" -> false" ...Optimize with: 'a == b', with a and b as literals -> equal(a, b)
 OK
  -- working on ""ABC" == "ABC" -> true" ...Optimize with: 'a == b', with a and b as literals -> equal(a, b)
 OK
  -- working on "33 == 44 -> false" ...Optimize with: 'a == b', with a and b as literals -> equal(a, b)
 OK
  -- working on "44 == 33 -> false" ...Optimize with: 'a == b', with a and b as literals -> equal(a, b)
 OK
  -- working on "33 == 33 -> true" ...Optimize with: 'a == b', with a and b as literals -> equal(a, b)
 OK
  -- working on "3.3 == 4.4 -> false" ...Optimize with: 'a == b', with a and b as literals -> equal(a, b)
 OK
  -- working on "4.4 == 3.3 -> false" ...Optimize with: 'a == b', with a and b as literals -> equal(a, b)
 OK
  -- working on "3.3 == 3.3 -> true" ...Optimize with: 'a == b', with a and b as literals -> equal(a, b)
 OK
  -- working on ""3.3" == 4.4 -> false" ...Optimize with: 'a == b', with a and b as literals -> equal(a, b)
 OK
  -- working on ""4.4" == 3.3 -> false" ...Optimize with: 'a == b', with a and b as literals -> equal(a, b)
 OK
  -- working on ""3.3" == 3.3 -> true" ...Optimize with: 'a == b', with a and b as literals -> equal(a, b)
 OK
  -- working on "3.3 == "4.4" -> false" ...Optimize with: 'a == b', with a and b as literals -> equal(a, b)
 OK
  -- working on "4.4 == "3.3" -> false" ...Optimize with: 'a == b', with a and b as literals -> equal(a, b)
 OK
  -- working on "3.3 == "3.3" -> true" ...Optimize with: 'a == b', with a and b as literals -> equal(a, b)
 OK
  -- working on "-Infinity == +Infinity -> false" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: 'a == b', with a and b as literals -> equal(a, b)
 OK
  -- working on "+Infinity == -Infinity -> false" ...Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: 'a == b', with a and b as literals -> equal(a, b)
 OK
  -- working on "+Infinity == +Infinity -> true" ...Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: 'a == b', with a and b as literals -> equal(a, b)
 OK
  -- working on "-Infinity == -Infinity -> true" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: 'a == b', with a and b as literals -> equal(a, b)
 OK
  -- working on ""ABC" === "XYZ" -> false" ...Optimize with: 'a === b', with a and b as literals -> strictly_equal(a, b)
 OK
  -- working on ""XYZ" === "ABC" -> false" ...Optimize with: 'a === b', with a and b as literals -> strictly_equal(a, b)
 OK
  -- working on ""ABC" === "ABC" -> true" ...Optimize with: 'a === b', with a and b as literals -> strictly_equal(a, b)
 OK
  -- working on "33 === 44 -> false" ...Optimize with: 'a === b', with a and b as literals -> strictly_equal(a, b)
 OK
  -- working on "44 === 33 -> false" ...Optimize with: 'a === b', with a and b as literals -> strictly_equal(a, b)
 OK
  -- working on "33 === 33 -> true" ...Optimize with: 'a === b', with a and b as literals -> strictly_equal(a, b)
 OK
  -- working on "3.3 === 4.4 -> false" ...Optimize with: 'a === b', with a and b as literals -> strictly_equal(a, b)
 OK
  -- working on "4.4 === 3.3 -> false" ...Optimize with: 'a === b', with a and b as literals -> strictly_equal(a, b)
 OK
  -- working on "3.3 === 3.3 -> true" ...Optimize with: 'a === b', with a and b as literals -> strictly_equal(a, b)
 OK
  -- working on ""3.3" === 4.4 -> false" ...Optimize with: 'a === b', with a and b as literals -> strictly_equal(a, b)
 OK
  -- working on ""4.4" === 3.3 -> false" ...Optimize with: 'a === b', with a and b as literals -> strictly_equal(a, b)
 OK
  -- working on ""3.3" === 3.3 -> false" ...Optimize with: 'a === b', with a and b as literals -> strictly_equal(a, b)
 OK
  -- working on "3.3 === "4.4" -> false" ...Optimize with: 'a === b', with a and b as literals -> strictly_equal(a, b)
 OK
  -- working on "4.4 === "3.3" -> false" ...Optimize with: 'a === b', with a and b as literals -> strictly_equal(a, b)
 OK
  -- working on "3.3 === "3.3" -> false" ...Optimize with: 'a === b', with a and b as literals -> strictly_equal(a, b)
 OK
  -- working on "-Infinity === +Infinity -> false" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: 'a === b', with a and b as literals -> strictly_equal(a, b)
 OK
  -- working on "+Infinity === -Infinity -> false" ...Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: 'a === b', with a and b as literals -> strictly_equal(a, b)
 OK
  -- working on "+Infinity === +Infinity -> true" ...Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: 'a === b', with a and b as literals -> strictly_equal(a, b)
 OK
  -- working on "-Infinity === -Infinity -> true" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: 'a === b', with a and b as literals -> strictly_equal(a, b)
 OK
  -- working on ""ABC" != "XYZ" -> true" ...Optimize with: 'a != b', with a and b as literals -> not_equal(a, b)
 OK
  -- working on ""XYZ" != "ABC" -> true" ...Optimize with: 'a != b', with a and b as literals -> not_equal(a, b)
 OK
  -- working on ""ABC" != "ABC" -> false" ...Optimize with: 'a != b', with a and b as literals -> not_equal(a, b)
 OK
  -- working on "33 != 44 -> true" ...Optimize with: 'a != b', with a and b as literals -> not_equal(a, b)
 OK
  -- working on "44 != 33 -> true" ...Optimize with: 'a != b', with a and b as literals -> not_equal(a, b)
 OK
  -- working on "33 != 33 -> false" ...Optimize with: 'a != b', with a and b as literals -> not_equal(a, b)
 OK
  -- working on "3.3 != 4.4 -> true" ...Optimize with: 'a != b', with a and b as literals -> not_equal(a, b)
 OK
  -- working on "4.4 != 3.3 -> true" ...Optimize with: 'a != b', with a and b as literals -> not_equal(a, b)
 OK
  -- working on "3.3 != 3.3 -> false" ...Optimize with: 'a != b', with a and b as literals -> not_equal(a, b)
 OK
  -- working on ""3.3" != 4.4 -> true" ...Optimize with: 'a != b', with a and b as literals -> not_equal(a, b)
 OK
  -- working on ""4.4" != 3.3 -> true" ...Optimize with: 'a != b', with a and b as literals -> not_equal(a, b)
 OK
  -- working on ""3.3" != 3.3 -> false" ...Optimize with: 'a != b', with a and b as literals -> not_equal(a, b)
 OK
  -- working on "3.3 != "4.4" -> true" ...Optimize with: 'a != b', with a and b as literals -> not_equal(a, b)
 OK
  -- working on "4.4 != "3.3" -> true" ...Optimize with: 'a != b', with a and b as literals -> not_equal(a, b)
 OK
  -- working on "3.3 != "3.3" -> false" ...Optimize with: 'a != b', with a and b as literals -> not_equal(a, b)
 OK
  -- working on "-Infinity != +Infinity -> true" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: 'a != b', with a and b as literals -> not_equal(a, b)
 OK
  -- working on "+Infinity != -Infinity -> true" ...Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: 'a != b', with a and b as literals -> not_equal(a, b)
 OK
  -- working on "+Infinity != +Infinity -> false" ...Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: 'a != b', with a and b as literals -> not_equal(a, b)
 OK
  -- working on "-Infinity != -Infinity -> false" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: 'a != b', with a and b as literals -> not_equal(a, b)
 OK
  -- working on ""ABC" !== "XYZ" -> true" ...Optimize with: 'a !== b', with a and b as literals -> strictly_not_equal(a, b)
 OK
  -- working on ""XYZ" !== "ABC" -> true" ...Optimize with: 'a !== b', with a and b as literals -> strictly_not_equal(a, b)
 OK
  -- working on ""ABC" !== "ABC" -> false" ...Optimize with: 'a !== b', with a and b as literals -> strictly_not_equal(a, b)
 OK
  -- working on "33 !== 44 -> true" ...Optimize with: 'a !== b', with a and b as literals -> strictly_not_equal(a, b)
 OK
  -- working on "44 !== 33 -> true" ...Optimize with: 'a !== b', with a and b as literals -> strictly_not_equal(a, b)
 OK
  -- working on "33 !== 33 -> false" ...Optimize with: 'a !== b', with a and b as literals -> strictly_not_equal(a, b)
 OK
  -- working on "3.3 !== 4.4 -> true" ...Optimize with: 'a !== b', with a and b as literals -> strictly_not_equal(a, b)
 OK
  -- working on "4.4 !== 3.3 -> true" ...Optimize with: 'a !== b', with a and b as literals -> strictly_not_equal(a, b)
 OK
  -- working on "3.3 !== 3.3 -> false" ...Optimize with: 'a !== b', with a and b as literals -> strictly_not_equal(a, b)
 OK
  -- working on ""3.3" !== 4.4 -> true" ...Optimize with: 'a !== b', with a and b as literals -> strictly_not_equal(a, b)
 OK
  -- working on ""4.4" !== 3.3 -> true" ...Optimize with: 'a !== b', with a and b as literals -> strictly_not_equal(a, b)
 OK
  -- working on ""3.3" !== 3.3 -> true" ...Optimize with: 'a !== b', with a and b as literals -> strictly_not_equal(a, b)
 OK
  -- working on "3.3 !== "4.4" -> true" ...Optimize with: 'a !== b', with a and b as literals -> strictly_not_equal(a, b)
 OK
  -- working on "4.4 !== "3.3" -> true" ...Optimize with: 'a !== b', with a and b as literals -> strictly_not_equal(a, b)
 OK
  -- working on "3.3 !== "3.3" -> true" ...Optimize with: 'a !== b', with a and b as literals -> strictly_not_equal(a, b)
 OK
  -- working on "-Infinity !== +Infinity -> true" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: 'a !== b', with a and b as literals -> strictly_not_equal(a, b)
 OK
  -- working on "+Infinity !== -Infinity -> true" ...Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: 'a !== b', with a and b as literals -> strictly_not_equal(a, b)
 OK
  -- working on "+Infinity !== +Infinity -> false" ...Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: 'a !== b', with a and b as literals -> strictly_not_equal(a, b)
 OK
  -- working on "-Infinity !== -Infinity -> false" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: 'a !== b', with a and b as literals -> strictly_not_equal(a, b)
 OK
  -- working on "33 == "XYZ" -> false" ...Optimize with: 'a == b', with a and b as literals -> equal(a, b)
 OK
  -- working on ""ABC" === 4.4 -> false" ...Optimize with: 'a === b', with a and b as literals -> strictly_equal(a, b)
 OK
  -- working on "+Infinity != 'not a number' -> false" ...Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: 'a != b', with a and b as literals -> not_equal(a, b)
 OK
  -- working on "'not a number' !== -Infinity -> true" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: 'a !== b', with a and b as literals -> strictly_not_equal(a, b)
 OK
  -- working on ""ABC" ~~ "XYZ" -> false" ...*** Comparing PROGRAM (node) vs PROGRAM (JSON)
*** Comparing DIRECTIVE_LIST (node) vs DIRECTIVE_LIST (JSON)
*** Comparing SMART_MATCH (node) vs SMART_MATCH (JSON)
*** Comparing STRING (node) vs STRING (JSON)
*** Comparing STRING (node) vs STRING (JSON)
Optimize with: 'a ~~ b', with a as a literal and b as a regular expression -> smart_match(a, b)
*** Comparing PROGRAM (node) vs PROGRAM (JSON)
*** Comparing DIRECTIVE_LIST (node) vs DIRECTIVE_LIST (JSON)
*** Comparing FALSE (node) vs FALSE (JSON)
 OK
  -- working on ""XYZ" ~~ "ABC" -> false" ...Optimize with: 'a ~~ b', with a as a literal and b as a regular expression -> smart_match(a, b)
 OK
  -- working on ""ABC" ~~ "ABC" -> true" ...Optimize with: 'a ~~ b', with a as a literal and b as a regular expression -> smart_match(a, b)
 OK
  -- working on "33 ~~ 44 -> false" ...Optimize with: 'a ~~ b', with a as a literal and b as a regular expression -> smart_match(a, b)
 OK
  -- working on "44 ~~ 33 -> false" ...Optimize with: 'a ~~ b', with a as a literal and b as a regular expression -> smart_match(a, b)
 OK
  -- working on "33 ~~ 33 -> true" ...Optimize with: 'a ~~ b', with a as a literal and b as a regular expression -> smart_match(a, b)
 OK
  -- working on "3.3 ~~ 4.4 -> false" ...Optimize with: 'a ~~ b', with a as a literal and b as a regular expression -> smart_match(a, b)
 OK
  -- working on "4.4 ~~ 3.3 -> false" ...Optimize with: 'a ~~ b', with a as a literal and b as a regular expression -> smart_match(a, b)
 OK
  -- working on "3.3 ~~ 3.3 -> true" ...Optimize with: 'a ~~ b', with a as a literal and b as a regular expression -> smart_match(a, b)
 OK
  -- working on ""3.3" ~~ 4.4 -> false" ...Optimize with: 'a ~~ b', with a as a literal and b as a regular expression -> smart_match(a, b)
 OK
  -- working on ""4.4" ~~ 3.3 -> false" ...Optimize with: 'a ~~ b', with a as a literal and b as a regular expression -> smart_match(a, b)
 OK
  -- working on ""3.3" ~~ 3.3 -> true" ...Optimize with: 'a ~~ b', with a as a literal and b as a regular expression -> smart_match(a, b)
 OK
  -- working on ""3.3xyz" ~~ 3.3 -> true" ...Optimize with: 'a ~~ b', with a as a literal and b as a regular expression -> smart_match(a, b)
 OK
  -- working on "3.3 ~~ "4.4" -> false" ...Optimize with: 'a ~~ b', with a as a literal and b as a regular expression -> smart_match(a, b)
 OK
  -- working on "4.4 ~~ "3.3" -> false" ...Optimize with: 'a ~~ b', with a as a literal and b as a regular expression -> smart_match(a, b)
 OK
  -- working on "4.4 ~~ "   3.3   " -> false" ...Optimize with: 'a ~~ b', with a as a literal and b as a regular expression -> smart_match(a, b)
 OK
  -- working on "3.3 ~~ "3.3" -> true" ...Optimize with: 'a ~~ b', with a as a literal and b as a regular expression -> smart_match(a, b)
 OK
  -- working on "3.3 ~~ " 3.3 and more" -> true" ...Optimize with: 'a ~~ b', with a as a literal and b as a regular expression -> smart_match(a, b)
 OK
  -- working on "-Infinity ~~ +Infinity -> false" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: 'a ~~ b', with a as a literal and b as a regular expression -> smart_match(a, b)
 OK
  -- working on "+Infinity ~~ -Infinity -> false" ...Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: 'a ~~ b', with a as a literal and b as a regular expression -> smart_match(a, b)
 OK
  -- working on "+Infinity ~~ +Infinity -> true" ...Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: 'a ~~ b', with a as a literal and b as a regular expression -> smart_match(a, b)
 OK
  -- working on "-Infinity ~~ -Infinity -> true" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: 'a ~~ b', with a as a literal and b as a regular expression -> smart_match(a, b)
 OK
 : OK
As2JsOptimizerUnitTests::test_optimizer_logical
  -- working on "!true -> false" ...Optimize with: '!a' where 'a' is a literal -> 'true' or 'false'
 OK
  -- working on "!false -> true" ...Optimize with: '!a' where 'a' is a literal -> 'true' or 'false'
 OK
  -- working on "!null -> true" ...Optimize with: '!a' where 'a' is a literal -> 'true' or 'false'
 OK
  -- working on "!undefined -> true" ...Optimize with: '!a' where 'a' is a literal -> 'true' or 'false'
 OK
  -- working on "!0 -> true" ...Optimize with: '!a' where 'a' is a literal -> 'true' or 'false'
 OK
  -- working on "!65 -> false" ...Optimize with: '!a' where 'a' is a literal -> 'true' or 'false'
 OK
  -- working on "!0.0 -> true" ...Optimize with: '!a' where 'a' is a literal -> 'true' or 'false'
 OK
  -- working on "!6.5 -> false" ...Optimize with: '!a' where 'a' is a literal -> 'true' or 'false'
 OK
  -- working on "!"" -> true" ...Optimize with: '!a' where 'a' is a literal -> 'true' or 'false'
 OK
  -- working on "!"empty" -> false" ...Optimize with: '!a' where 'a' is a literal -> 'true' or 'false'
 OK
  -- working on "!!!a -> !a" ...Optimize with: '!!!a' whatever 'a' is -> logical_not(a)
 OK
  -- working on "true && a -> a" ...Optimize with: 'true && a' -> 'a'
 OK
  -- working on ""true" && a -> a" ...Optimize with: 'true && a' -> 'a'
 OK
  -- working on "104 && a -> a" ...Optimize with: 'true && a' -> 'a'
 OK
  -- working on "1.04 && a -> a" ...Optimize with: 'true && a' -> 'a'
 OK
  -- working on "false && a -> false" ...Optimize with: 'false && a' -> 'false'
 OK
  -- working on "'' && a -> ''" ...Optimize with: 'false && a' -> 'false'
 OK
  -- working on "0 && a -> 0" ...Optimize with: 'false && a' -> 'false'
 OK
  -- working on "0.0 && a -> 0.0" ...Optimize with: 'false && a' -> 'false'
 OK
  -- working on "null && a -> null" ...Optimize with: 'false && a' -> 'false'
 OK
  -- working on "undefined && a -> undefined" ...Optimize with: 'false && a' -> 'false'
 OK
  -- working on "undefined && a -> undefined" ...Optimize with: 'false && a' -> 'false'
 OK
  -- working on "true || a -> true" ...Optimize with: 'true || a' -> 'true'
 OK
  -- working on ""true" || a -> a" ...Optimize with: 'true || a' -> 'true'
 OK
  -- working on "104 || a -> 104" ...Optimize with: 'true || a' -> 'true'
 OK
  -- working on "1.04 || a -> 1.04" ...Optimize with: 'true || a' -> 'true'
 OK
  -- working on "false || a -> a" ...Optimize with: 'false || a' -> 'a'
 OK
  -- working on "'' || a -> a" ...Optimize with: 'false || a' -> 'a'
 OK
  -- working on "0 || a -> a" ...Optimize with: 'false || a' -> 'a'
 OK
  -- working on "0.0 || a -> a" ...Optimize with: 'false || a' -> 'a'
 OK
  -- working on "null || a -> a" ...Optimize with: 'false || a' -> 'a'
 OK
  -- working on "undefined || a -> a" ...Optimize with: 'false || a' -> 'a'
 OK
  -- working on "true ^^ true -> false" ...Optimize with: 'literal ^^ literal' -> 'literal'
 OK
  -- working on "false ^^ false -> false" ...Optimize with: 'literal ^^ literal' -> 'literal'
 OK
  -- working on "false ^^ true -> true" ...Optimize with: 'literal ^^ literal' -> 'literal'
 OK
  -- working on "true ^^ false -> true" ...Optimize with: 'literal ^^ literal' -> 'literal'
 OK
  -- working on "1.33 ^^ false -> 1.33" ...Optimize with: 'literal ^^ literal' -> 'literal'
 OK
  -- working on "null ^^ 45 -> 45" ...Optimize with: 'literal ^^ literal' -> 'literal'
 OK
  -- working on ""here" ^^ undefined -> "here"" ...Optimize with: 'literal ^^ literal' -> 'literal'
 OK
  -- working on "0 ^^ "here" -> "here"" ...Optimize with: 'literal ^^ literal' -> 'literal'
 OK
  -- working on "0 ^^ 0.0 -> false" ...Optimize with: 'literal ^^ literal' -> 'literal'
 OK
  -- working on ""too" ^^ "much" -> false" ...Optimize with: 'literal ^^ literal' -> 'literal'
 OK
  -- working on "if(!a) b else c -> if(a) c else b" ...Optimize with: '{ { a; } };' -> '{ a; }'
Optimize with: 'if(!a) b else c' -> 'if(a) c else b'
 OK
  -- working on "if(!!a) -> if(a)" ...Optimize with: 'if(!!a)' -> 'if(a)'
 OK
  -- working on "while(!!a) -> while(a)" ...Optimize with: 'if(!!a)' -> 'if(a)'
 OK
  -- working on "for(a; !!b; c) d -> for(a; b; c) d" ...Optimize with: 'for(a; !!b; c) d' -> for(a; b; c) d
 OK
  -- working on "!!a ? b : c -> a ? b : c" ...Optimize with: '!!a ? b : c' -> a ? b : c
 OK
  -- working on "a && b || c -> a ? b : c" ...Optimize with: 'a && b || c' -> 'a ? b : c'
 OK
 : OK
As2JsOptimizerUnitTests::test_optimizer_match -- warning: test As2JsOptimizerUnitTests::test_optimizer_match() skip since you are compiling with a g++ version prior to 4.9.0
 : OK
As2JsOptimizerUnitTests::test_optimizer_multiplicative
  -- working on "55 * 123 -> 6765" ...Optimize with: 'a * b' -> multiply(a, b)
 OK
  -- working on "5.5 * 123 -> 676.5" ...Optimize with: 'a * b' -> multiply(a, b)
 OK
  -- working on "55 * 1.23 -> 67.65" ...Optimize with: 'a * b' -> multiply(a, b)
 OK
  -- working on "5.5 * 1.23 -> 6.765" ...Optimize with: 'a * b' -> multiply(a, b)
 OK
  -- working on "5.5 * NaN -> NaN" ...Optimize with: 'a * b' -> multiply(a, b)
 OK
  -- working on "NaN * 1.23 -> NaN" ...Optimize with: 'a * b' -> multiply(a, b)
 OK
  -- working on "NaN * a -> NaN" ...Optimize with: 'NaN * a' -> NaN, if a has no side effects
 OK
  -- working on "a * NaN -> NaN" ...Optimize with: 'a * NaN' -> NaN, if a has no side effects
 OK
  -- working on "a() * NaN -> a() * NaN" ...*** Comparing PROGRAM (node) vs PROGRAM (JSON)
*** Comparing DIRECTIVE_LIST (node) vs DIRECTIVE_LIST (JSON)
*** Comparing MULTIPLY (node) vs MULTIPLY (JSON)
*** Comparing CALL (node) vs CALL (JSON)
*** Comparing IDENTIFIER (node) vs IDENTIFIER (JSON)
*** Comparing LIST (node) vs LIST (JSON)
*** Comparing FLOAT64 (node) vs FLOAT64 (JSON)
*** Comparing PROGRAM (node) vs PROGRAM (JSON)
*** Comparing DIRECTIVE_LIST (node) vs DIRECTIVE_LIST (JSON)
*** Comparing MULTIPLY (node) vs MULTIPLY (JSON)
*** Comparing CALL (node) vs CALL (JSON)
*** Comparing IDENTIFIER (node) vs IDENTIFIER (JSON)
*** Comparing LIST (node) vs LIST (JSON)
*** Comparing FLOAT64 (node) vs FLOAT64 (JSON)
 OK
  -- working on "NaN * a() -> NaN * a()" ...*** Comparing PROGRAM (node) vs PROGRAM (JSON)
*** Comparing DIRECTIVE_LIST (node) vs DIRECTIVE_LIST (JSON)
*** Comparing MULTIPLY (node) vs MULTIPLY (JSON)
*** Comparing FLOAT64 (node) vs FLOAT64 (JSON)
*** Comparing CALL (node) vs CALL (JSON)
*** Comparing IDENTIFIER (node) vs IDENTIFIER (JSON)
*** Comparing LIST (node) vs LIST (JSON)
*** Comparing PROGRAM (node) vs PROGRAM (JSON)
*** Comparing DIRECTIVE_LIST (node) vs DIRECTIVE_LIST (JSON)
*** Comparing MULTIPLY (node) vs MULTIPLY (JSON)
*** Comparing FLOAT64 (node) vs FLOAT64 (JSON)
*** Comparing CALL (node) vs CALL (JSON)
*** Comparing IDENTIFIER (node) vs IDENTIFIER (JSON)
*** Comparing LIST (node) vs LIST (JSON)
 OK
  -- working on "123 / 7 -> 17" ...Optimize with: 'a / b' -> divide(a, b)
 OK
  -- working on "12.3 / 7 -> 1.7" ...Optimize with: 'a / b' -> divide(a, b)
 OK
  -- working on "123 / 0.7 -> 1.7" ...Optimize with: 'a / b' -> divide(a, b)
 OK
  -- working on "1.23 / 0.1 -> 12.3" ...Optimize with: 'a / b' -> divide(a, b)
 OK
  -- working on "1.23 / NaN -> NaN" ...Optimize with: 'a / b' -> divide(a, b)
 OK
  -- working on "NaN / 0.1 -> NaN" ...Optimize with: 'a / b' -> divide(a, b)
 OK
  -- working on "NaN / a -> NaN" ...Optimize with: 'NaN / a' -> NaN, if a has no side effects
 OK
  -- working on "a / NaN -> NaN" ...Optimize with: 'a / NaN' -> NaN, if a has no side effects
 OK
  -- working on "123 / 0 -> Infinity" ...Optimize with: 'a / b' -> divide(a, b)
 OK
  -- working on "-123 / 0 -> -Infinity" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: 'a / b' -> divide(a, b)
 OK
  -- working on "123 % 31 -> 30" ...Optimize with: 'a % b' -> modulo(a, b)
 OK
  -- working on "49.2 % 31 -> 18.2" ...Optimize with: 'a % b' -> modulo(a, b)
 OK
  -- working on "123 % 3.1 -> 21.0" ...Optimize with: 'a % b' -> modulo(a, b)
 OK
  -- working on "12.3 % 3.1 -> 3.0" ...Optimize with: 'a % b' -> modulo(a, b)
 OK
  -- working on "12.3 % NaN -> NaN" ...Optimize with: 'a % b' -> modulo(a, b)
 OK
  -- working on "NaN % 12.3 -> NaN" ...Optimize with: 'a % b' -> modulo(a, b)
 OK
  -- working on "NaN % a -> NaN" ...Optimize with: 'NaN % a' -> NaN, if a has no side effects
 OK
  -- working on "a % NaN -> NaN" ...Optimize with: 'a % NaN' -> NaN, if a has no side effects
 OK
  -- working on "123 % 0 -> NaN" ...Optimize with: 'a % b' -> modulo(a, b)
 OK
  -- working on "-123 % 0 -> NaN" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: 'a % b' -> modulo(a, b)
 OK
  -- working on "123 ** 3 -> 1860867" ...Optimize with: 'a ** b' -> power(a, b)
 OK
  -- working on "1.23 ** 3 -> 1.860867" ...Optimize with: 'a ** b' -> power(a, b)
 OK
  -- working on "123 ** 0.3 -> 4.236151986" ...Optimize with: 'a ** b' -> power(a, b)
 OK
  -- working on "12.3 ** 0.3 -> 2.123105295" ...Optimize with: 'a ** b' -> power(a, b)
 OK
  -- working on "12.3 ** NaN -> NaN" ...Optimize with: 'a ** b' -> power(a, b)
 OK
  -- working on "NaN ** 12.3 -> NaN" ...Optimize with: 'a ** b' -> power(a, b)
 OK
  -- working on "a ** NaN -> NaN" ...Optimize with: 'a % NaN' -> NaN, if a has no side effects
 OK
  -- working on "NaN ** a -> NaN" ...Optimize with: 'NaN ** a' -> NaN, if a has no side effects
 OK
  -- working on "a() * 3.5 -> a() * 3.5" ...*** Comparing PROGRAM (node) vs PROGRAM (JSON)
*** Comparing DIRECTIVE_LIST (node) vs DIRECTIVE_LIST (JSON)
*** Comparing MULTIPLY (node) vs MULTIPLY (JSON)
*** Comparing CALL (node) vs CALL (JSON)
*** Comparing IDENTIFIER (node) vs IDENTIFIER (JSON)
*** Comparing LIST (node) vs LIST (JSON)
*** Comparing FLOAT64 (node) vs FLOAT64 (JSON)
*** Comparing PROGRAM (node) vs PROGRAM (JSON)
*** Comparing DIRECTIVE_LIST (node) vs DIRECTIVE_LIST (JSON)
*** Comparing MULTIPLY (node) vs MULTIPLY (JSON)
*** Comparing CALL (node) vs CALL (JSON)
*** Comparing IDENTIFIER (node) vs IDENTIFIER (JSON)
*** Comparing LIST (node) vs LIST (JSON)
*** Comparing FLOAT64 (node) vs FLOAT64 (JSON)
 OK
  -- working on "3.5 * a() -> 3.5 * a()" ...*** Comparing PROGRAM (node) vs PROGRAM (JSON)
*** Comparing DIRECTIVE_LIST (node) vs DIRECTIVE_LIST (JSON)
*** Comparing MULTIPLY (node) vs MULTIPLY (JSON)
*** Comparing FLOAT64 (node) vs FLOAT64 (JSON)
*** Comparing CALL (node) vs CALL (JSON)
*** Comparing IDENTIFIER (node) vs IDENTIFIER (JSON)
*** Comparing LIST (node) vs LIST (JSON)
*** Comparing PROGRAM (node) vs PROGRAM (JSON)
*** Comparing DIRECTIVE_LIST (node) vs DIRECTIVE_LIST (JSON)
*** Comparing MULTIPLY (node) vs MULTIPLY (JSON)
*** Comparing FLOAT64 (node) vs FLOAT64 (JSON)
*** Comparing CALL (node) vs CALL (JSON)
*** Comparing IDENTIFIER (node) vs IDENTIFIER (JSON)
*** Comparing LIST (node) vs LIST (JSON)
 OK
 : OK
As2JsOptimizerUnitTests::test_optimizer_relational
  -- working on ""ABC" < "XYZ" -> true" ...Optimize with: 'a < b', with a and b as literals -> less(a, b)
 OK
  -- working on ""XYZ" < "ABC" -> false" ...Optimize with: 'a < b', with a and b as literals -> less(a, b)
 OK
  -- working on ""ABC" < "ABC" -> false" ...Optimize with: 'a < b', with a and b as literals -> less(a, b)
 OK
  -- working on "33 < 44 -> true" ...Optimize with: 'a < b', with a and b as literals -> less(a, b)
 OK
  -- working on "44 < 33 -> false" ...Optimize with: 'a < b', with a and b as literals -> less(a, b)
 OK
  -- working on "33 < 33 -> false" ...Optimize with: 'a < b', with a and b as literals -> less(a, b)
 OK
  -- working on "3.3 < 4.4 -> true" ...Optimize with: 'a < b', with a and b as literals -> less(a, b)
 OK
  -- working on "4.4 < 3.3 -> false" ...Optimize with: 'a < b', with a and b as literals -> less(a, b)
 OK
  -- working on "3.3 < 3.3 -> false" ...Optimize with: 'a < b', with a and b as literals -> less(a, b)
 OK
  -- working on ""3.3" < 4.4 -> true" ...Optimize with: 'a < b', with a and b as literals -> less(a, b)
 OK
  -- working on ""4.4" < 3.3 -> false" ...Optimize with: 'a < b', with a and b as literals -> less(a, b)
 OK
  -- working on ""3.3" < 3.3 -> false" ...Optimize with: 'a < b', with a and b as literals -> less(a, b)
 OK
  -- working on "3.3 < "4.4" -> true" ...Optimize with: 'a < b', with a and b as literals -> less(a, b)
 OK
  -- working on "4.4 < "3.3" -> false" ...Optimize with: 'a < b', with a and b as literals -> less(a, b)
 OK
  -- working on "3.3 < "3.3" -> false" ...Optimize with: 'a < b', with a and b as literals -> less(a, b)
 OK
  -- working on "-Infinity < +Infinity -> true" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: 'a < b', with a and b as literals -> less(a, b)
 OK
  -- working on "+Infinity < -Infinity -> false" ...Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: 'a < b', with a and b as literals -> less(a, b)
 OK
  -- working on "+Infinity < +Infinity -> false" ...Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: 'a < b', with a and b as literals -> less(a, b)
 OK
  -- working on "-Infinity < -Infinity -> false" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: 'a < b', with a and b as literals -> less(a, b)
 OK
  -- working on ""ABC" <= "XYZ" -> true" ...Optimize with: 'a <= b', with a and b as literals -> less_equal(a, b)
 OK
  -- working on ""XYZ" <= "ABC" -> false" ...Optimize with: 'a <= b', with a and b as literals -> less_equal(a, b)
 OK
  -- working on ""ABC" <= "ABC" -> true" ...Optimize with: 'a <= b', with a and b as literals -> less_equal(a, b)
 OK
  -- working on "33 <= 44 -> true" ...Optimize with: 'a <= b', with a and b as literals -> less_equal(a, b)
 OK
  -- working on "44 <= 33 -> false" ...Optimize with: 'a <= b', with a and b as literals -> less_equal(a, b)
 OK
  -- working on "33 <= 33 -> true" ...Optimize with: 'a <= b', with a and b as literals -> less_equal(a, b)
 OK
  -- working on "3.3 <= 4.4 -> true" ...Optimize with: 'a <= b', with a and b as literals -> less_equal(a, b)
 OK
  -- working on "4.4 <= 3.3 -> false" ...Optimize with: 'a <= b', with a and b as literals -> less_equal(a, b)
 OK
  -- working on "3.3 <= 3.3 -> true" ...Optimize with: 'a <= b', with a and b as literals -> less_equal(a, b)
 OK
  -- working on ""3.3" <= 4.4 -> true" ...Optimize with: 'a <= b', with a and b as literals -> less_equal(a, b)
 OK
  -- working on ""4.4" <= 3.3 -> false" ...Optimize with: 'a <= b', with a and b as literals -> less_equal(a, b)
 OK
  -- working on ""3.3" <= 3.3 -> true" ...Optimize with: 'a <= b', with a and b as literals -> less_equal(a, b)
 OK
  -- working on "3.3 <= "4.4" -> true" ...Optimize with: 'a <= b', with a and b as literals -> less_equal(a, b)
 OK
  -- working on "4.4 <= "3.3" -> false" ...Optimize with: 'a <= b', with a and b as literals -> less_equal(a, b)
 OK
  -- working on "3.3 <= "3.3" -> true" ...Optimize with: 'a <= b', with a and b as literals -> less_equal(a, b)
 OK
  -- working on "-Infinity <= +Infinity -> true" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: 'a <= b', with a and b as literals -> less_equal(a, b)
 OK
  -- working on "+Infinity <= -Infinity -> false" ...Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: 'a <= b', with a and b as literals -> less_equal(a, b)
 OK
  -- working on "+Infinity <= +Infinity -> true" ...Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: 'a <= b', with a and b as literals -> less_equal(a, b)
 OK
  -- working on "-Infinity <= -Infinity -> true" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: 'a <= b', with a and b as literals -> less_equal(a, b)
 OK
  -- working on ""ABC" > "XYZ" -> false" ...Optimize with: 'a > b', with a and b as literals -> greater(a, b)
 OK
  -- working on ""XYZ" > "ABC" -> true" ...Optimize with: 'a > b', with a and b as literals -> greater(a, b)
 OK
  -- working on ""ABC" > "ABC" -> false" ...Optimize with: 'a > b', with a and b as literals -> greater(a, b)
 OK
  -- working on "33 > 44 -> false" ...Optimize with: 'a > b', with a and b as literals -> greater(a, b)
 OK
  -- working on "44 > 33 -> true" ...Optimize with: 'a > b', with a and b as literals -> greater(a, b)
 OK
  -- working on "33 > 33 -> false" ...Optimize with: 'a > b', with a and b as literals -> greater(a, b)
 OK
  -- working on "3.3 > 4.4 -> false" ...Optimize with: 'a > b', with a and b as literals -> greater(a, b)
 OK
  -- working on "4.4 > 3.3 -> true" ...Optimize with: 'a > b', with a and b as literals -> greater(a, b)
 OK
  -- working on "3.3 > 3.3 -> false" ...Optimize with: 'a > b', with a and b as literals -> greater(a, b)
 OK
  -- working on ""3.3" > 4.4 -> false" ...Optimize with: 'a > b', with a and b as literals -> greater(a, b)
 OK
  -- working on ""4.4" > 3.3 -> true" ...Optimize with: 'a > b', with a and b as literals -> greater(a, b)
 OK
  -- working on ""3.3" > 3.3 -> false" ...Optimize with: 'a > b', with a and b as literals -> greater(a, b)
 OK
  -- working on "3.3 > "4.4" -> false" ...Optimize with: 'a > b', with a and b as literals -> greater(a, b)
 OK
  -- working on "4.4 > "3.3" -> true" ...Optimize with: 'a > b', with a and b as literals -> greater(a, b)
 OK
  -- working on "3.3 > "3.3" -> false" ...Optimize with: 'a > b', with a and b as literals -> greater(a, b)
 OK
  -- working on "-Infinity > +Infinity -> false" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: 'a > b', with a and b as literals -> greater(a, b)
 OK
  -- working on "+Infinity > -Infinity -> true" ...Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: 'a > b', with a and b as literals -> greater(a, b)
 OK
  -- working on "+Infinity > +Infinity -> false" ...Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: 'a > b', with a and b as literals -> greater(a, b)
 OK
  -- working on "-Infinity > -Infinity -> false" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: 'a > b', with a and b as literals -> greater(a, b)
 OK
  -- working on ""ABC" >= "XYZ" -> false" ...Optimize with: 'a > b', with a and b as literals -> greater_equal(a, b)
 OK
  -- working on ""XYZ" >= "ABC" -> true" ...Optimize with: 'a > b', with a and b as literals -> greater_equal(a, b)
 OK
  -- working on ""ABC" >= "ABC" -> true" ...Optimize with: 'a > b', with a and b as literals -> greater_equal(a, b)
 OK
  -- working on "33 >= 44 -> false" ...Optimize with: 'a > b', with a and b as literals -> greater_equal(a, b)
 OK
  -- working on "44 >= 33 -> true" ...Optimize with: 'a > b', with a and b as literals -> greater_equal(a, b)
 OK
  -- working on "33 >= 33 -> true" ...Optimize with: 'a > b', with a and b as literals -> greater_equal(a, b)
 OK
  -- working on "3.3 >= 4.4 -> false" ...Optimize with: 'a > b', with a and b as literals -> greater_equal(a, b)
 OK
  -- working on "4.4 >= 3.3 -> true" ...Optimize with: 'a > b', with a and b as literals -> greater_equal(a, b)
 OK
  -- working on "3.3 >= 3.3 -> true" ...Optimize with: 'a > b', with a and b as literals -> greater_equal(a, b)
 OK
  -- working on ""3.3" >= 4.4 -> false" ...Optimize with: 'a > b', with a and b as literals -> greater_equal(a, b)
 OK
  -- working on ""4.4" >= 3.3 -> true" ...Optimize with: 'a > b', with a and b as literals -> greater_equal(a, b)
 OK
  -- working on ""3.3" >= 3.3 -> true" ...Optimize with: 'a > b', with a and b as literals -> greater_equal(a, b)
 OK
  -- working on "3.3 >= "4.4" -> false" ...Optimize with: 'a > b', with a and b as literals -> greater_equal(a, b)
 OK
  -- working on "4.4 >= "3.3" -> true" ...Optimize with: 'a > b', with a and b as literals -> greater_equal(a, b)
 OK
  -- working on "3.3 >= "3.3" -> true" ...Optimize with: 'a > b', with a and b as literals -> greater_equal(a, b)
 OK
  -- working on "-Infinity >= +Infinity -> false" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: 'a > b', with a and b as literals -> greater_equal(a, b)
 OK
  -- working on "+Infinity >= -Infinity -> true" ...Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: 'a > b', with a and b as literals -> greater_equal(a, b)
 OK
  -- working on "+Infinity >= +Infinity -> true" ...Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: 'a > b', with a and b as literals -> greater_equal(a, b)
 OK
  -- working on "-Infinity >= -Infinity -> true" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: 'a > b', with a and b as literals -> greater_equal(a, b)
 OK
  -- working on "33 < "XYZ" -> false" ...Optimize with: 'a < b', with a and b as literals -> less(a, b)
 OK
  -- working on ""ABC" <= 4.4 -> false" ...Optimize with: 'a <= b', with a and b as literals -> less_equal(a, b)
 OK
  -- working on "+Infinity > 'not a number' -> false" ...Optimize with: '+a' when 'a' is a literal -> 'a'
Optimize with: 'a > b', with a and b as literals -> greater(a, b)
 OK
  -- working on "'not a number' >= -Infinity -> false" ...Optimize with: '-a' when 'a' is a literal -> 'negate(a)'
Optimize with: 'a > b', with a and b as literals -> greater_equal(a, b)
 OK
 : OK
As2JsOptimizerUnitTests::test_optimizer_statements
  -- working on "if(true) a -> a" ...Optimize with: 'if(true) a' -> 'a'
Optimize with: '{ { a; } };' -> '{ a; }'
 OK
  -- working on "if(true) a else b -> a" ...Optimize with: 'if(true) a; else b;' -> 'a'
Optimize with: '{ { a; } };' -> '{ a; }'
 OK
  -- working on "if(false) a -> " ...Optimize with: 'if(false) a' -> ''
 OK
  -- working on "if(false) a else b -> b" ...Optimize with: 'if(true) a; else b;' -> 'b'
Optimize with: '{ { a; } };' -> '{ a; }'
 OK
  -- working on "while(true) a -> for(;;) a" ...Optimize with: 'while(true) a;' -> 'for(;;) a;'
 OK
  -- working on "while(false) a -> ;" ...Optimize with: 'while(false) a;' -> ';'
 OK
  -- working on "do { a; } while(true); -> for(;;) a;" ...Optimize with: '{ { a; } };' -> '{ a; }'
Optimize with: 'do { a; } while(true);' -> 'for(;;) a;'
 OK
  -- working on "do { a; } while(false) -> a;" ...Optimize with: '{ { a; } };' -> '{ a; }'
Optimize with: 'do { a; } while(false);' -> 'a;'
Optimize with: '{ { a; } };' -> '{ a; }'
 OK
 : OK
As2JsOptionsUnitTests::test_options : OK
As2JsParserUnitTests::test_parser_basics
  -- working on "empty program" ... OK
  -- working on "empty program with comments" ... OK
  -- working on "empty program with semi-colons" ... OK
  -- working on "unexpected "else" instruction" ... OK
  -- working on "unexpected "}" character" ... OK
  -- working on "empty package" ... OK
 : OK
As2JsParserUnitTests::test_parser_class
  -- working on "class with a valid invariant contract" ................................ OK
  -- working on "class with a valid invariant contract (missing identifier)" ... OK
  -- working on "class with a valid invariant contract (missing colon)" ... OK
  -- working on "class without a name" ... OK
  -- working on "class with an invalid extend" ... OK
  -- working on "class not finished with '};'" ... OK
  -- working on "forward class declaration not finished with ';'" ... OK
  -- working on "class with a missing name followed by '{'" ... OK
  -- working on "class with a missing name followed by 'extends'" ... OK
  -- working on "class with a missing name followed by 'implements'" ... OK
  -- working on "an empty class" ... OK
  -- working on "class defined inside a package" ... OK
  -- working on "class derived from another and three interfaces" ... OK
  -- working on "class using extends after implements" ... OK
  -- working on "class using public instead of extends" ... OK
  -- working on "class using ':' and public instead of extends" ... OK
  -- working on "class using private instead of extends" ... OK
  -- working on "class using ':' and private instead of extends" ... OK
  -- working on "class using protected instead of extends" ... OK
  -- working on "class using ':' and protected instead of extends" ... OK
  -- working on "class using a colon (:) and extends" ... OK
  -- working on "class using a colon (:) and implements" ... OK
  -- working on "class using a colon (:) and an unknown keyword" ... OK
  -- working on "class using a spurious colon (:)" ... OK
  -- working on "class using two implements" ... OK
 : OK
As2JsParserUnitTests::test_parser_function
  -- working on "'a+b' function" ................................ OK
  -- working on "'a+b' operator" ................................ OK
  -- working on "all operators redefined" ................................ OK
  -- working on "'random' function" ................................ OK
  -- working on "invalid "out" with "..." in function parameter list" ... OK
  -- working on "invalid "out" with "const" in function parameter list" ... OK
  -- working on "invalid assignment to "..." in function parameter list" ................................ OK
  -- working on "')' missing to close function parameter list" ... OK
  -- working on "',' missing to separate function parameters" ... OK
  -- working on "'...' must be last" ... OK
  -- working on "getter/setter cannot be an operator" ... OK
  -- working on "getter/setter expects an identifier, a string, or '('" ... OK
  -- working on "function expressions cannot be getters nor setters" ... OK
  -- working on "function cannot have more than one name" ... OK
  -- working on "function must be named" ... OK
  -- working on "else without an if() breaks the directive list" ... OK
  -- working on "two parameters separated by < and > instead of a comma" ... OK
 : OK
As2JsParserUnitTests::test_parser_variable
  -- working on "list of variables" ... OK
  -- working on "list of variables" ... OK
  -- working on "list of constants" ... OK
  -- working on "variable missing its name" ... OK
  -- working on "variable of attributes" ... OK
 : OK
As2JsParserUnitTests::test_parser
  -- working on "'{' missing after package name" ... OK
  -- working on "'}' missing after package directives" ... OK
  -- working on "invalid package name (ends with '.')" ... OK
  -- working on "invalid package name (includes keyword 'private')" ... OK
  -- working on "invalid package name (ends with 'private')" ... OK
  -- working on "import packages" ... OK
  -- working on "import packages: invalid name string/member mix" ... OK
  -- working on "import packages: invalid name, missing string or identifier" ... OK
  -- working on "import packages: * cannot be used when renaming a package" ... OK
  -- working on "import packages: * must be last" ... OK
  -- working on "import packages: * must be last" ... OK
  -- working on "import packages cannot include identifiers and strings" ... OK
  -- working on "import package names cannot end with a period" ... OK
  -- working on "import package cannot just be an asterisk" ... OK
  -- working on "import package cannot exclude and include at the same time" ... OK
  -- working on "import package cannot include and exclude at the same time" ... OK
  -- working on "import package extras not namespace, include, nor exclude" ... OK
  -- working on "import with an unexpected token after the comma" ... OK
  -- working on "import two commas in a row..." ... OK
  -- working on "import two period one after another (i.e. a range)..." ... OK
  -- working on "import three periods one after another (i.e. a rest)..." ... OK
  -- working on "use namespace" ... OK
  -- working on "namespace defining an enumeration" ... OK
  -- working on "namespace snapwebsites;" ... OK
  -- working on "namespace without a name makes things inside private" ... OK
  -- working on "namespace without a name and some attributes" ................................ OK
  -- working on "namespace without a name and some attributes including 'private'" ... OK
  -- working on "forward enumeration definition" ... OK
  -- working on "forward enumeration without a name" ... OK
  -- working on ""forward" enumeration without a ';'" ... OK
  -- working on "enumeration starting with a ','" ... OK
  -- working on "enumeration with a duplicate ','" ... OK
  -- working on "enumeration with a missing identifier with assignment" ... OK
  -- working on "enumeration with a string instead of the identifier" ... OK
  -- working on "enumeration with two identifiers in a row" ... OK
  -- working on "enumeration missing the '}' at the end" ... OK
  -- working on "enumeration missing the '}' and ';' at the end" ... OK
  -- working on "type with a range of integers" ... OK
  -- working on "a mod type" ... OK
  -- working on "a mod type using a string" ... OK
  -- working on "a mod type without the number" ... OK
  -- working on "a type without a string instead of a number (left)" ... OK
  -- working on "a type without a string instead of a number (right)" ... OK
  -- working on "a type with a float and an integer" ... OK
  -- working on "a type with an integer and a float" ... OK
  -- working on "type with '...' instead of '..'" ... OK
  -- working on "type with '...' instead of '..' and an inverted range" ... OK
  -- working on "type with '...' instead of '..' and floats" ... OK
  -- working on "type with '...' instead of '..' and inverted range of floats" ... OK
  -- working on "verify all the pragma names" ... OK
  -- working on "verify all the pragma 'prima' tests" ................................ OK
  -- working on "verify that setting or clearing a pragma results in the correct value" ................................ OK
  -- working on "verify that (-) is invalid as a pragma parameter" ... OK
  -- working on "Yield an expression" ... OK
  -- working on "Yield without the mandatory expression" ... OK
  -- working on "'while' with a broken block" ... OK
  -- working on "'while' with a broken block v2" ... OK
  -- working on "'while' with a broken block v3" ... OK
  -- working on "'while' with a broken block v4" ... OK
  -- working on "'while' with a broken block v5" ... OK
  -- working on "'switch' 'with' 'break' and 'continue'" ... OK
  -- working on "Invalid break/continue" ... OK
  -- working on "Missing ':' after case expression, and try/catch" ... OK
  -- working on "catch(void) is not valid" ... OK
  -- working on "try/finally require a block" ... OK
  -- working on "valid and invalid if/else and goto" ................................ OK
  -- working on "if without a block before the else inside a do/while loop" ................................ OK
  -- working on "do loop without a while" ................................ OK
  -- working on "do loop with its while missing '('" ................................ OK
  -- working on "do loop with its while missing ')'" ................................ OK
  -- working on "forever loop" ................................ OK
  -- working on "standard for loop and broken switch statements" ... OK
  -- working on "standard for loop and broken switch statements" ... OK
  -- working on "synchronized errors" ... OK
  -- working on "a few extra valid and invalid for loops" ................................ OK
  -- working on "for each expects" ................................ OK
  -- working on "invalid list of stand alone attributes" ................................ OK
  -- working on "colon by itself or with attributes" ... OK
  -- working on "legal empty statements" ... OK
  -- working on "illegal keywords in statements" ... OK
  -- working on "arrays with empty items" ................................ OK
  -- working on "valid and invalid function calls" ................................ OK
  -- working on "enum assignment accepts conditional values" ................................ OK
  -- working on "conditional missing the ':' character" ................................ OK
  -- working on "scope in expression must be followed by an identifier" ................................ OK
  -- working on "function call without the ')'" ... OK
  -- working on "array access without the ']'" ... OK
  -- working on "grouped expressions without the ')'" ... OK
  -- working on "array literal without the ']'" ... OK
  -- working on "object literal without the '}'" ... OK
  -- working on "object literal without all the ','" ... OK
  -- working on "object literal without all the ':'" ... OK
  -- working on "object literal without all the field names" ... OK
  -- working on "object literal with private/protected/public fields without a valid scope" ................................ OK
  -- working on "object literal without ':' followed by '}'" ... OK
  -- working on "object literal without ':' followed by ';'" ... OK
  -- working on "object literal without ':' followed by ',' and '}'" ... OK
  -- working on "object literal without ':' followed by ',' and ';'" ... OK
 : OK
As2JsPositionUnitTests::test_names : OK
As2JsPositionUnitTests::test_counters : OK
As2JsPositionUnitTests::test_output : OK
As2JsRCUnitTests::test_basics : OK
As2JsRCUnitTests::test_load_from_var : OK
As2JsRCUnitTests::test_load_from_local : OK
As2JsRCUnitTests::test_load_from_user_config : OK
As2JsRCUnitTests::test_load_from_system_config --- test_load_from_system_config() requires root access to modify the /etc/as2js directory ---  : OK
As2JsRCUnitTests::test_empty_home --- test_empty_home() not run, the other rc unit tests are not compatible with this test ---  : OK
As2JsStreamUnitTests::test_filter_iso88591 : OK
As2JsStreamUnitTests::test_filter_utf8............................... : OK
As2JsStreamUnitTests::test_filter_utf16.................................. : OK
As2JsStreamUnitTests::test_filter_utf32...............................-+ : OK
As2JsStreamUnitTests::test_filter_detect : OK
As2JsStreamUnitTests::test_string_input : OK
As2JsStreamUnitTests::test_stdin : OK
As2JsStreamUnitTests::test_file : OK
As2JsStreamUnitTests::test_bad_impl : OK
As2JsStreamUnitTests::test_stdout
test_as2js[30038]: version 0.1.0, seed is 1416669157
As2JsStreamUnitTests::test_stdout_destructive
test_as2js[30040]: version 0.1.0, seed is 1416669157
As2JsRCUnitTests::test_empty_home : OK
OK (1)

Finished running the tests on Sat Nov 22 07:12:37 PST 2014