diff --git a/tests/src/Main.hx b/tests/src/Main.hx index d080699..5448bbe 100644 --- a/tests/src/Main.hx +++ b/tests/src/Main.hx @@ -19,11 +19,23 @@ class Main { } runTest("Array", new ArrayCase()); runTest("BinOp", new BinOpCase()); + runTest("Enum", new EnumCase()); runTest("EvalOrder", new EvalOrderCase()); - runTest("Math", new MathCase()); runTest("Float", new FloatCase()); runTest("IntIterator", new IntIteratorCase()); + runTest("Lambda", new LambdaCase()); + runTest("List", new ListCase()); + runTest("Math", new MathCase()); + runTest("Map", new MapCase()); runTest("Misc", new MiscCase()); + runTest("Reflect", new ReflectCase()); + runTest("Regex", new RegexCase()); + runTest("Std", new StdCase()); + runTest("String", new StringCase()); + runTest("StringBuf", new StringBufCase()); + runTest("StringTools", new StringToolsCase()); + // TODO: UnicodeCase.hx? + // TODO: UnicodeStringCase.hx? Util.printTestResults(); #end } diff --git a/tests/src/Util.hx b/tests/src/Util.hx index d03842b..05e3ca0 100644 --- a/tests/src/Util.hx +++ b/tests/src/Util.hx @@ -18,6 +18,10 @@ class Util { if (deepCompareArrays(value, expected)) passed = true; } + else if (Std.isOfType(value, Enum) && Std.isOfType(expected, Enum)) { + if(Type.enumEq(value, expected)) + passed = true; + } if (passed) { passedTestUnits++; @@ -60,7 +64,7 @@ class Util { } public static function startUnitTest(path:String) { - //Sys.println("Running unit tests " + path); + Sys.println("Running unit tests in " + path); currentTestPath.push(path); totalTestUnits++; } @@ -71,13 +75,14 @@ class Util { } public static function printTestResults() { - Sys.println("-----------------------------------------------------------"); + Sys.println("-----------------------------RESULTS-----------------------------"); Sys.println("Total Units: " + totalTestUnits); Sys.println("Total tests passed: " + passedTestUnits); Sys.println("Total tests failed: " + failedTestUnits); if(skippedKnownBugs > 0) Sys.println("Skipped known bugs: " + skippedKnownBugs); //Sys.println("Finished unit tests " + currentTestPath.pop()); + Sys.println("-----------------------------RESULTS-----------------------------"); } public static function parse(str:String) { @@ -85,7 +90,14 @@ class Util { p.allowTypes = true; p.allowMetadata = true; p.allowJSON = true; - return p.parseString(str); + var result = null; + try { + result = p.parseString(str); + } catch (e:Dynamic) { + Sys.println("## Error parsing: " + str); + Sys.println("## Error: " + e); + } + return result; } public static function getInterp() { @@ -95,6 +107,7 @@ class Util { //interp.allowPublicVariables = true; interp.variables.set("Math", Math); interp.variables.set("Std", Std); + interp.variables.set("Type", Type); interp.variables.set("StringTools", StringTools); return interp; } diff --git a/tests/src/benchmark/Benchmark.hx b/tests/src/benchmark/Benchmark.hx index 1bc0f21..1bb7959 100644 --- a/tests/src/benchmark/Benchmark.hx +++ b/tests/src/benchmark/Benchmark.hx @@ -19,50 +19,18 @@ class Benchmark { total += time; Sys.println('--------------------$name BENCHMARK--------------------'); - Sys.println('Running $iterations times...'); - // Sys.println('Lowest Time: ${Util.exScienceN(times[0])}'); - // Sys.println('Average Time: ${Util.exScienceN(total/iterations)}'); - // Sys.println('Highest Time: ${Util.exScienceN(times[times.length-1])}'); - Sys.println('Lowest Time: ${Util.convertToReadableTime(times[0])}'); - Sys.println('Average Time: ${Util.convertToReadableTime(total/iterations)}'); - Sys.println('Highest Time: ${Util.convertToReadableTime(times[times.length-1])}'); - graph(); + + if (total == 0 || times.length <= 0) { + Sys.println('BENCHMARK UNNOTICABLE, TOOK 0 SECONDS'); + } else { + Sys.println('Running $iterations times...'); + Sys.println('Lowest Time: ${Util.convertToReadableTime(times[0])}'); + Sys.println('Average Time: ${Util.convertToReadableTime(total/iterations)}'); + Sys.println('Highest Time: ${Util.convertToReadableTime(times[times.length-1])}'); + } + Sys.println('--------------------$name BENCHMARK--------------------'); } - public function graph() { - var size:{width:Int, height:Int} = {width: 20, height: 14}; - - var collumRange:Float = times[times.length-1]-times[0]; - var counts:Array = cast new haxe.ds.Vector(size.width); - - for (time in times) { - var index:Int = Std.int((time - times[0]) / (collumRange / size.width)); - counts[index]++; - } - - var normalizedCounts:Array = [for (count in counts) count / times.length]; - var gridFilling:Array = [for (count in normalizedCounts) Math.round(count*size.height)]; - - trace(normalizedCounts,gridFilling); - for (y in 0...size.height) { - for (x in 0...size.width) { - Sys.print("*"); - } - Sys.print("\n"); - - } - } - - // public static function remapToRange(value:Float, start1:Float, stop1:Float, start2:Float, stop2:Float):Float - // { - // return start2 + (value - start1) * ((stop2 - start2) / (stop1 - start1)); - // } - - public function benchmark() { - var array:Array = []; - - for (i in 0...10000) - array.push(Math.random()); - } + public function benchmark() {} } \ No newline at end of file diff --git a/tests/src/tests/EnumCase.hx b/tests/src/tests/EnumCase.hx new file mode 100644 index 0000000..ea31d74 --- /dev/null +++ b/tests/src/tests/EnumCase.hx @@ -0,0 +1,38 @@ +package tests; + +class EnumCase extends TestCase { + override function setup() { + super.setup(); + } + + override function getNewInterp() { + var interp = super.getNewInterp(); + interp.variables.set("assertEq", Util.assertEq); + interp.variables.set("SomeEnum", SomeEnum); + interp.variables.set("Type", Type); + return interp; + } + + override function run() { + assertEq("SomeEnum.NoArguments;", SomeEnum.NoArguments); + assertEq("SomeEnum.OneArgument('foo');", SomeEnum.OneArgument("foo")); + assertEq("SomeEnum.TwoArguments('foo', 'bar');", SomeEnum.TwoArguments("foo", "bar")); + + assertEq("Type.enumEq(SomeEnum.NoArguments, SomeEnum.NoArguments);", Type.enumEq(SomeEnum.NoArguments, SomeEnum.NoArguments)); + assertEq("Type.enumEq(SomeEnum.NoArguments, SomeEnum.OneArgument('foo'));", Type.enumEq(SomeEnum.NoArguments, SomeEnum.OneArgument("foo"))); + assertEq("Type.enumEq(SomeEnum.OneArgument('foo'), SomeEnum.OneArgument('foo'));", Type.enumEq(SomeEnum.OneArgument("foo"), SomeEnum.OneArgument("foo"))); + assertEq("Type.enumEq(SomeEnum.OneArgument('foo'), SomeEnum.TwoArguments('foo', 'bar'));", Type.enumEq(SomeEnum.OneArgument("foo"), SomeEnum.TwoArguments("foo", "bar"))); + assertEq("Type.enumEq(SomeEnum.TwoArguments('foo', 'bar'), SomeEnum.TwoArguments('foo', 'bar'));", Type.enumEq(SomeEnum.TwoArguments("foo", "bar"), SomeEnum.TwoArguments("foo", "bar"))); + assertEq("Type.enumEq(SomeEnum.TwoArguments('foo', 'bar'), SomeEnum.NoArguments);", Type.enumEq(SomeEnum.TwoArguments("foo", "bar"), SomeEnum.NoArguments)); + } + + override function teardown() { + super.teardown(); + } +} + +enum SomeEnum { + NoArguments; + OneArgument(arg:String); + TwoArguments(arg1:String, arg2:String); +} \ No newline at end of file diff --git a/tests/src/tests/LambdaCase.hx b/tests/src/tests/LambdaCase.hx new file mode 100644 index 0000000..4a7455c --- /dev/null +++ b/tests/src/tests/LambdaCase.hx @@ -0,0 +1,35 @@ +package tests; + +class LambdaCase extends TestCase { + override function setup() { + super.setup(); + } + + override function getNewInterp() { + var interp = super.getNewInterp(); + interp.variables.set("Lambda", Lambda); + return interp; + } + + override function run() { + // has + assertEq("Lambda.has([1,2,3],1)", Lambda.has([1,2,3],1)); + assertEq("Lambda.has([1,2,3],4)", Lambda.has([1,2,3],4)); + assertEq("Lambda.has([],null)", Lambda.has([],null)); + assertEq("Lambda.has([null],null)", Lambda.has([null],null)); + + // exists + assertEq("Lambda.exists([1, 2, 3], function(i) return i == 2)", Lambda.exists([1, 2, 3], function(i) return i == 2)); + assertEq("Lambda.exists([1, 2, 3], function(i) return i == 4)", Lambda.exists([1, 2, 3], function(i) return i == 4)); + assertEq("Lambda.exists([], function(x) return true)", Lambda.exists([], function(x) return true)); + + // foreach + assertEq("Lambda.foreach([2, 4, 6],function(i) return i % 2 == 0)", Lambda.foreach([2, 4, 6],function(i) return i % 2 == 0)); + assertEq("Lambda.foreach([2, 4, 7],function(i) return i % 2 == 0)", Lambda.foreach([2, 4, 7],function(i) return i % 2 == 0)); + assertEq("Lambda.foreach([], function(x) return false)", Lambda.foreach([], function(x) return false)); + } + + override function teardown() { + super.teardown(); + } +} \ No newline at end of file diff --git a/tests/src/tests/ListCase.hx b/tests/src/tests/ListCase.hx new file mode 100644 index 0000000..92ad2f8 --- /dev/null +++ b/tests/src/tests/ListCase.hx @@ -0,0 +1,37 @@ +package tests; + +class ListCase extends TestCase { + override function setup() { + super.setup(); + } + + override function getNewInterp() { + var interp = super.getNewInterp(); + interp.variables.set("List", List); + return interp; + } + + override function run() { + var l4 = new List(); + l4.add(1); + l4.add(2); + l4.add(3); + l4.add(5); + l4.add(8); + + headerCode = "var l4 = new List(); + l4.add(1); + l4.add(2); + l4.add(3); + l4.add(5); + l4.add(8);"; + + assertEq("[for (k=>v in l4) k]", [for (k=>v in l4) k]); + assertEq("[for (k=>v in l4) v]", [for (k=>v in l4) v]); + assertEq("[for (k=>v in l4) k*v]", [for (k=>v in l4) k*v]); + } + + override function teardown() { + super.teardown(); + } +} \ No newline at end of file diff --git a/tests/src/tests/MapCase.hx b/tests/src/tests/MapCase.hx new file mode 100644 index 0000000..e768d3e --- /dev/null +++ b/tests/src/tests/MapCase.hx @@ -0,0 +1,23 @@ +package tests; + +class MapCase extends TestCase { + override function setup() { + super.setup(); + } + + override function getNewInterp() { + var interp = super.getNewInterp(); + interp.variables.set("IntMap", haxe.ds.IntMap); + interp.variables.set("ObjectMap", haxe.ds.ObjectMap); + interp.variables.set("StringMap", haxe.ds.StringMap); + return interp; + } + + override function run() { + Sys.println("TODO: Write tests for Map"); + } + + override function teardown() { + super.teardown(); + } +} \ No newline at end of file diff --git a/tests/src/tests/ReflectCase.hx b/tests/src/tests/ReflectCase.hx new file mode 100644 index 0000000..6f5b9fd --- /dev/null +++ b/tests/src/tests/ReflectCase.hx @@ -0,0 +1,58 @@ +package tests; + +class ReflectCase extends TestCase { + override function setup() { + super.setup(); + } + + override function getNewInterp() { + var interp = super.getNewInterp(); + interp.variables.set("Reflect", Reflect); + return interp; + } + + override function run() { + headerCode = "var x = { a: 1, b: null };"; + var x = { a: 1, b: null }; + + assertEq("Reflect.field(x, 'a')", Reflect.field(x, 'a')); + assertEq("Reflect.field(x, 'b')", Reflect.field(x, 'b')); + assertEq("Reflect.field(x, 'c')", Reflect.field(x, 'c')); + + assertEq("Reflect.hasField(x, 'a')", Reflect.hasField(x, 'a')); + assertEq("Reflect.hasField(x, 'b')", Reflect.hasField(x, 'b')); + assertEq("Reflect.hasField(x, 'c')", Reflect.hasField(x, 'c')); + + headerCode = "var n = null;"; + var n = null; + + assertEq("Reflect.field(n, n)", Reflect.field(n, n)); + assertEq("Reflect.field(1, 'foo')", Reflect.field(1, "foo")); + + headerCode = "var x = { a: 1, b: null };"; + + Reflect.setField(x, 'a', 2); assertEq("Reflect.setField(x, 'a', 2); x.a", x.a); + Reflect.setField(x, 'c', 'foo'); assertEq("Reflect.setField(x, 'c', 'foo'); Reflect.field(x, 'c')", Reflect.field(x, 'c')); + + headerCode = "var x = { a: 1, b: null };"; + + Reflect.setProperty(x, 'a', 2); assertEq("Reflect.setProperty(x, 'a', 2); x.a", x.a); + Reflect.setProperty(x, 'c', 'foo'); assertEq("Reflect.setProperty(x, 'c', 'foo'); Reflect.field(x, 'c')", Reflect.field(x, 'c')); + + headerCode = "var x = function(t) return 1; var y = function(t) return -1; var z = function(t) return 1;"; + var x = function(t) return 1; + var y = function(t) return -1; + var z = function(t) return 1; + + assertEq("Reflect.compareMethods(x,y)", Reflect.compareMethods(x,y)); + assertEq("Reflect.compareMethods(x,z)", Reflect.compareMethods(x,z)); + assertEq("Reflect.compareMethods(y,z)", Reflect.compareMethods(y,z)); + assertEq("Reflect.compareMethods(x,x)", Reflect.compareMethods(x,x)); + assertEq("Reflect.compareMethods(y,y)", Reflect.compareMethods(y,y)); + assertEq("Reflect.compareMethods(z,z)", Reflect.compareMethods(z,z)); + } + + override function teardown() { + super.teardown(); + } +} \ No newline at end of file diff --git a/tests/src/tests/RegexCase.hx b/tests/src/tests/RegexCase.hx new file mode 100644 index 0000000..70ea851 --- /dev/null +++ b/tests/src/tests/RegexCase.hx @@ -0,0 +1,142 @@ +package tests; + +class RegexCase extends TestCase { + override function setup() { + super.setup(); + + /*headerCode = " + var r = ~/a/; + var rg = ~/a/g; + var rg2 = ~/aa/g; + ";*/ + } + + override function getNewInterp() { + var interp = super.getNewInterp(); + interp.variables.set("assertEq", Util.assertEq); + interp.variables.set("EReg", EReg); + return interp; + } + + override function run() { + var r = ~/a/; + var rg = ~/a/g; + var rg2 = ~/aa/g; + + Util.runKnownBug("Regex Syntax doesn't work", () -> { + assertEq("~/a/;", r); + assertEq("~/a/g;", rg); + assertEq("~/aa/g;", rg2); + }); + + // TODO: implement better checking for regexes + //assertEq("new EReg('a', '');", r); + //assertEq("new EReg('a', 'g');", rg); + //assertEq("new EReg('aa', 'g');", rg2); + + @:privateAccess assertEq("new EReg('a', '').toString();", r.toString()); + @:privateAccess assertEq("new EReg('a', 'g').toString();", rg.toString()); + @:privateAccess assertEq("new EReg('aa', 'g').toString();", rg2.toString()); + + //assertEq(r.match("") == false); + //assertEq(r.match("b") == false); + //assertEq(r.match("a") == true); + //assertEq(r.matched(0) == "a"); + //assertEq(r.matchedLeft() == ""); + //assertEq(r.matchedRight() == ""); + //var pos = r.matchedPos(); + //assertEq(pos.pos == 0); + //assertEq(pos.len == 1); + + /*execute(' + assertEq(r.match("") == false; + r.match("b") == false; + r.match("a") == true; + r.matched(0) == "a"; + r.matchedLeft() == ""; + r.matchedRight() == ""; + var pos = r.matchedPos(); + pos.pos == 0; + pos.len == 1; + + r.match("aa") == true; + r.matched(0) == "a"; + r.matchedLeft() == ""; + r.matchedRight() == "a"; + var pos = r.matchedPos(); + pos.pos == 0; + pos.len == 1; + + rg.match("aa") == true; + rg.matched(0) == "a"; + rg.matchedLeft() == ""; + rg.matchedRight() == "a"; + var pos = rg.matchedPos(); + pos.pos == 0; + pos.len == 1; + + rg2.match("aa") == true; + rg2.matched(0) == "aa"; + rg2.matchedLeft() == ""; + rg2.matchedRight() == ""; + var pos = rg2.matchedPos(); + pos.pos == 0; + pos.len == 2; + + rg2.match("AaaBaaC") == true; + rg2.matched(0) == "aa"; + rg2.matchedLeft() == "A"; + rg2.matchedRight() == "BaaC"; + var pos = rg2.matchedPos(); + pos.pos == 1; + pos.len == 2; + + // split + ~/a/.split("") == [""]; + ~/a/.split("a") == ["",""]; + ~/a/.split("aa") == ["","a"]; + ~/a/.split("b") == ["b"]; + ~/a/.split("ab") == ["","b"]; + ~/a/.split("ba") == ["b",""]; + ~/a/.split("aba") == ["","ba"]; + ~/a/.split("bab") == ["b","b"]; + ~/a/.split("baba") == ["b","ba"]; + + // split + g + ~/a/g.split("") == [""]; + ~/a/g.split("a") == ["",""]; + ~/a/g.split("aa") == ["","",""]; + ~/a/g.split("b") == ["b"]; + ~/a/g.split("ab") == ["","b"]; + ~/a/g.split("ba") == ["b",""]; + ~/a/g.split("aba") == ["","b",""]; + ~/a/g.split("bab") == ["b","b"]; + ~/a/g.split("baba") == ["b","b",""]; + + // replace + ~/a/.replace("", "z") == ""; + ~/a/.replace("a", "z") == "z"; + ~/a/.replace("aa", "z") == "za"; + ~/a/.replace("b", "z") == "b"; + ~/a/.replace("ab", "z") == "zb"; + ~/a/.replace("ba", "z") == "bz"; + ~/a/.replace("aba", "z") == "zba"; + ~/a/.replace("bab", "z") == "bzb"; + ~/a/.replace("baba", "z") == "bzba"; + + // replace + g + ~/a/g.replace("", "z") == ""; + ~/a/g.replace("a", "z") == "z"; + ~/a/g.replace("aa", "z") == "zz"; + ~/a/g.replace("b", "z") == "b"; + ~/a/g.replace("ab", "z") == "zb"; + ~/a/g.replace("ba", "z") == "bz"; + ~/a/g.replace("aba", "z") == "zbz"; + ~/a/g.replace("bab", "z") == "bzb"; + ~/a/g.replace("baba", "z") == "bzbz";*/ + } + + override function teardown() { + super.teardown(); + } +} \ No newline at end of file diff --git a/tests/src/tests/StdCase.hx b/tests/src/tests/StdCase.hx new file mode 100644 index 0000000..2a5d377 --- /dev/null +++ b/tests/src/tests/StdCase.hx @@ -0,0 +1,210 @@ +package tests; + +class StdCase extends TestCase { + override function setup() { + super.setup(); + } + + override function getNewInterp() { + var interp = super.getNewInterp(); + interp.variables.set("Std", Std); + interp.variables.set("String", String); + interp.variables.set("Bool", Bool); + interp.variables.set("Float", Float); + interp.variables.set("Array", Array); + interp.variables.set("Int", Int); + return interp; + } + + override function run() { + var known:String = null; assertEq('var known:String = null; known is String;', known is String); + var unknown = null; assertEq('var unknown = null; unknown is String;', unknown is String); + assertEq('null is String;', null is String); + + assertEq('"" is String;', ("" is String)); + assertEq('false is Bool;', (false is Bool)); + assertEq("1 is Int;", (1 is Int)); + assertEq("1.5 is Int;", (1.5 is Int)); + assertEq("1.5 is Float;", (1.5 is Float)); + assertEq("[] is Array;", ([] is Array)); + + // isOfType + assertEq("var known:String = null; Std.isOfType(known, String);", Std.isOfType(known, String)); + + assertEq("var unknown = null; Std.isOfType(unknown, String);", Std.isOfType(unknown, String)); + assertEq("Std.isOfType(null, String);", Std.isOfType(null, String)); + + assertEq("Std.isOfType('', String);", Std.isOfType("", String)); + assertEq("Std.isOfType(false, Bool);", Std.isOfType(false, Bool)); + assertEq("Std.isOfType(1, Int)", Std.isOfType(1, Int)); + assertEq("Std.isOfType(1.5, Int);", Std.isOfType(1.5, Int)); + assertEq("Std.isOfType(1.5, Float);", Std.isOfType(1.5, Float)); + assertEq("Std.isOfType([], Array);", Std.isOfType([], Array)); + // Std.isOfType(cast unit.MyEnum.A, Array) == false; + + // instance + #if !js + assertEq("Std.downcast('', String)", Std.downcast("", String)); + Std.downcast("", String) == ""; + #end + + var a = []; + assertEq("var a = []; Std.downcast(a, Array)", Std.downcast(a, Array)); + assertEq("Std.downcast(null, Array)", Std.downcast(null, Array)); + assertEq("Std.downcast(null, String)", Std.downcast(null, String)); + + // string + /*var cwts = new ClassWithToString(); + var cwtsc = new ClassWithToStringChild(); + var cwtsc2 = new ClassWithToStringChild2(); + + Std.string(cwts) == "ClassWithToString.toString()"; + Std.string(cwtsc) == "ClassWithToString.toString()"; + Std.string(cwtsc2) == "ClassWithToStringChild2.toString()"; + + Std.string(SomeEnum.NoArguments) == "NoArguments"; + Std.string(SomeEnum.OneArgument("foo")) == "OneArgument(foo)";*/ + + assertEq("Std.string(null)", Std.string(null)); + + // int + assertEq("Std.int(-1.7)", Std.int(-1.7)); + assertEq("Std.int(-1.2)", Std.int(-1.2)); + assertEq("Std.int(-0.7)", Std.int(-0.7)); + assertEq("Std.int(-0.2)", Std.int(-0.2)); + assertEq("Std.int(0.7)", Std.int(0.7)); + assertEq("Std.int(0.2)", Std.int(0.2)); + + // general + assertEq("Std.parseInt('0')", Std.parseInt("0")); + assertEq("Std.parseInt('-1')", Std.parseInt("-1")); + + // preceeding zeroes + assertEq("Std.parseInt('0001')", Std.parseInt("0001")); + assertEq("Std.parseInt('0010')", Std.parseInt("0010")); + // trailing text + assertEq("Std.parseInt('100x123')", Std.parseInt("100x123")); + assertEq("Std.parseInt('12foo13')", Std.parseInt("12foo13")); + assertEq("Std.parseInt('23e2')", Std.parseInt("23e2")); + assertEq("Std.parseInt('0x10z')", Std.parseInt("0x10z")); + assertEq("Std.parseInt('0x10x123')", Std.parseInt("0x10x123")); + assertEq("Std.parseInt('0x10x123\\n')", Std.parseInt("0x10x123\n")); + assertEq("Std.parseInt('0xff\\n')", Std.parseInt("0xff\n")); + + // hexadecimals + assertEq("Std.parseInt('0xff')", Std.parseInt("0xff")); + assertEq("Std.parseInt('0x123')", Std.parseInt("0x123")); + assertEq("Std.parseInt('0XFF')", Std.parseInt("0XFF")); + assertEq("Std.parseInt('0X123')", Std.parseInt("0X123")); + assertEq("Std.parseInt('0X01')", Std.parseInt("0X01")); + assertEq("Std.parseInt('0x01')", Std.parseInt("0x01")); + + // signs + assertEq("Std.parseInt('123')", Std.parseInt("123")); + assertEq("Std.parseInt('+123')", Std.parseInt("+123")); + assertEq("Std.parseInt('-123')", Std.parseInt("-123")); + assertEq("Std.parseInt('0xa0')", Std.parseInt("0xa0")); + assertEq("Std.parseInt('+0xa0')", Std.parseInt("+0xa0")); + assertEq("Std.parseInt('-0xa0')", Std.parseInt("-0xa0")); + + // whitespace: space, horizontal tab, newline, vertical tab, form feed, and carriage return + assertEq("Std.parseInt(' 5')", Std.parseInt(" 5")); + assertEq("Std.parseInt(' \\t\\n\\x0b\\x0c\\r16')", Std.parseInt(" \t\n\x0b\x0c\r16")); + assertEq("Std.parseInt(' \\t\\n\\x0b\\x0c\\r0xa')", Std.parseInt(" \t\n\x0b\x0c\r0xa")); + + // whitespace and signs + assertEq("Std.parseInt(' 16')", Std.parseInt(" 16")); + assertEq("Std.parseInt(' -16')", Std.parseInt(" -16")); + assertEq("Std.parseInt(' +16')", Std.parseInt(" +16")); + assertEq("Std.parseInt(' 0x10')", Std.parseInt(" 0x10")); + assertEq("Std.parseInt(' -0x10')", Std.parseInt(" -0x10")); + assertEq("Std.parseInt(' +0x10')", Std.parseInt(" +0x10")); + + // binary and octal unsupported + assertEq("Std.parseInt('010')", Std.parseInt("010")); + assertEq("Std.parseInt('0b10')", Std.parseInt("0b10")); + // null + assertEq("Std.parseInt(null)", Std.parseInt(null)); + // no number + assertEq("Std.parseInt('')", Std.parseInt("")); + assertEq("Std.parseInt('abcd')", Std.parseInt("abcd")); + assertEq("Std.parseInt('a10')", Std.parseInt("a10")); + // invalid use of signs + assertEq("Std.parseInt('++123')", Std.parseInt("++123")); + assertEq("Std.parseInt('+-123')", Std.parseInt("+-123")); + assertEq("Std.parseInt('-+123')", Std.parseInt("-+123")); + assertEq("Std.parseInt('--123')", Std.parseInt("--123")); + assertEq("Std.parseInt('+ 123')", Std.parseInt("+ 123")); + assertEq("Std.parseInt('- 123')", Std.parseInt("- 123")); + assertEq("Std.parseInt('++0x123')", Std.parseInt("++0x123")); + assertEq("Std.parseInt('+-0x123')", Std.parseInt("+-0x123")); + assertEq("Std.parseInt('-+0x123')", Std.parseInt("-+0x123")); + assertEq("Std.parseInt('--0x123')", Std.parseInt("--0x123")); + assertEq("Std.parseInt('+ 0x123')", Std.parseInt("+ 0x123")); + assertEq("Std.parseInt('- 0x123')", Std.parseInt("- 0x123")); + + // hexadecimal prefix with no number + //unspec(Std.parseInt.bind("0x")); + //unspec(Std.parseInt.bind("0x C")); + //unspec(Std.parseInt.bind("0x+A")); + + // parseFloat + + // general + assertEq("Std.parseFloat('0')", Std.parseFloat('0')); + assertEq("Std.parseFloat('0.0')", Std.parseFloat('0.0')); + // preceeding zeroes + assertEq("Std.parseFloat('0001')", Std.parseFloat('0001')); + assertEq("Std.parseFloat('0010')", Std.parseFloat('0010')); + // trailing text + assertEq("Std.parseFloat('100x123')", Std.parseFloat('100x123')); + assertEq("Std.parseFloat('12foo13')", Std.parseFloat('12foo13')); + assertEq("Std.parseFloat('5.3 ')", Std.parseFloat('5.3 ')); + assertEq("Std.parseFloat('5.3 1')", Std.parseFloat('5.3 1')); + // signs + assertEq("Std.parseFloat('123.45')", Std.parseFloat('123.45')); + assertEq("Std.parseFloat('+123.45')", Std.parseFloat('+123.45')); + assertEq("Std.parseFloat(' \\t\\n\\x0b\\x0c\\r1.6')", Std.parseFloat('\t\n\x0b\x0c\r1.6')); + // whitespace: space, horizontal tab, newline, vertical tab, form feed, and carriage return + // whitespace and signs + assertEq("Std.parseFloat(' 1.6')", Std.parseFloat(' 1.6')); + assertEq("Std.parseFloat(' -1.6')", Std.parseFloat(' -1.6')); + assertEq("Std.parseFloat(' +1.6')", Std.parseFloat(' +1.6')); + // exponent + assertEq("Std.parseFloat('2.426670815e12')", Std.parseFloat('2.426670815e12')); + assertEq("Std.parseFloat('2.426670815E12')", Std.parseFloat('2.426670815E12')); + assertEq("Std.parseFloat('2.426670815e+12')", Std.parseFloat('2.426670815e+12')); + assertEq("Std.parseFloat('2.426670815E+12')", Std.parseFloat('2.426670815E+12')); + assertEq("Std.parseFloat('2.426670815e-12')", Std.parseFloat('2.426670815e-12')); + assertEq("Std.parseFloat('2.426670815E-12')", Std.parseFloat('2.426670815E-12')); + + #if !interp + assertEq("Std.parseFloat('6e')", Std.parseFloat('6e')); + assertEq("Std.parseFloat('6e')", Std.parseFloat('6e')); + #end + // null + assertEq("Math.isNaN(Std.parseFloat(null))", Math.isNaN(Std.parseFloat(null))); + // no number + assertEq("Math.isNaN(Std.parseFloat(''))", Math.isNaN(Std.parseFloat(""))); + assertEq("Math.isNaN(Std.parseFloat('abcd'))", Math.isNaN(Std.parseFloat("abcd"))); + assertEq("Math.isNaN(Std.parseFloat('a10'))", Math.isNaN(Std.parseFloat("a10"))); + // invalid use of signs + assertEq("Math.isNaN(Std.parseFloat('++12.3'))", Math.isNaN(Std.parseFloat("++12.3"))); + assertEq("Math.isNaN(Std.parseFloat('+-12.3'))", Math.isNaN(Std.parseFloat("+-12.3"))); + assertEq("Math.isNaN(Std.parseFloat('-+12.3'))", Math.isNaN(Std.parseFloat("-+12.3"))); + assertEq("Math.isNaN(Std.parseFloat('--12.3'))", Math.isNaN(Std.parseFloat("--12.3"))); + assertEq("Math.isNaN(Std.parseFloat('+ 12.3'))", Math.isNaN(Std.parseFloat("+ 12.3"))); + assertEq("Math.isNaN(Std.parseFloat('- 12.3'))", Math.isNaN(Std.parseFloat("- 12.3"))); + + // random + // var x = Std.random(2); + // //x in [0,1]; + // Std.random(1) == 0; + // Std.random(0) == 0; + // Std.random(-100) == 0; + } + + override function teardown() { + super.teardown(); + } +} \ No newline at end of file diff --git a/tests/src/tests/StringBufCase.hx b/tests/src/tests/StringBufCase.hx new file mode 100644 index 0000000..edccb6f --- /dev/null +++ b/tests/src/tests/StringBufCase.hx @@ -0,0 +1,34 @@ +package tests; + +class StringBufCase extends TestCase { + override function setup() { + super.setup(); + } + + override function getNewInterp() { + var interp = super.getNewInterp(); + interp.variables.set("Std", Std); + interp.variables.set("StringBuf", StringBuf); + return interp; + } + + override function run() { + var x = new StringBuf(); + x.addSub("abcdefg", 1); + assertEq('var x = new StringBuf(); x.addSub("abcdefg", 1); x.toString()', x.toString()); + + Util.runKnownBug("Emojis dont work", () -> { + var x = new StringBuf(); + x.add("👽"); + assertEq('var x = new StringBuf(); x.add("👽"); x.toString()', x.toString()); + }); + + var x = new StringBuf(); + x.add(0x1F47D); + assertEq('var x = new StringBuf(); x.add(0x1F47D); x.toString()', x.toString()); + } + + override function teardown() { + super.teardown(); + } +} \ No newline at end of file diff --git a/tests/src/tests/StringCase.hx b/tests/src/tests/StringCase.hx new file mode 100644 index 0000000..cc048c5 --- /dev/null +++ b/tests/src/tests/StringCase.hx @@ -0,0 +1,111 @@ +package tests; + +class StringCase extends TestCase { + override function setup() { + super.setup(); + } + + override function getNewInterp() { + var interp = super.getNewInterp(); + interp.variables.set("Std", Std); + interp.variables.set("String", String); + return interp; + } + + override function run() { + assertEq('"foo"', "foo"); + var str = "foo"; + assertEq('var str = "foo"; str == new String(str)', str == new String(str)); + + //Util.runKnownBug("Using StringTools; not working", () -> { + //}); + assertEq('"foo".toUpperCase()', "foo".toUpperCase()); + assertEq('"_bar".toUpperCase()', "_bar".toUpperCase()); + assertEq('"123b".toUpperCase()', "123b".toUpperCase()); + assertEq('"".toUpperCase()', "".toUpperCase()); + assertEq('"A".toUpperCase()', "A".toUpperCase()); + assertEq('"FOO".toLowerCase()', "FOO".toLowerCase()); + assertEq('"_BAR".toLowerCase()', "_BAR".toLowerCase()); + assertEq('"_BAR".toLowerCase()', "_BAR".toLowerCase()); + assertEq('"123B".toLowerCase()', "123B".toLowerCase()); + assertEq('"".toLowerCase()', "".toLowerCase()); + assertEq('"a".toLowerCase()', "a".toLowerCase()); + + headerCode = 'var s = "foo1bar";'; + var s = "foo1bar"; + + assertEq("s.charAt(0)", s.charAt(0)); + assertEq("s.charAt(1)", s.charAt(1)); + assertEq("s.charAt(2)", s.charAt(2)); + assertEq("s.charAt(3)", s.charAt(3)); + assertEq("s.charAt(4)", s.charAt(4)); + assertEq("s.charAt(5)", s.charAt(5)); + assertEq("s.charAt(6)", s.charAt(6)); + assertEq("s.charAt(7)", s.charAt(7)); + assertEq("s.charAt(-1)", s.charAt(-1)); + assertEq('"".charAt(0)', "".charAt(0)); + assertEq('"".charAt(1)', "".charAt(1)); + assertEq('"".charAt(-1)', "".charAt(-1)); + + headerCode = 'var s = "foo1bar";'; + var s = "foo1bar"; + + assertEq("s.charCodeAt(0)", s.charCodeAt(0)); + assertEq("s.charCodeAt(1)", s.charCodeAt(1)); + assertEq("s.charCodeAt(2)", s.charCodeAt(2)); + assertEq("s.charCodeAt(3)", s.charCodeAt(3)); + assertEq("s.charCodeAt(4)", s.charCodeAt(4)); + assertEq("s.charCodeAt(5)", s.charCodeAt(5)); + assertEq("s.charCodeAt(6)", s.charCodeAt(6)); + assertEq("s.charCodeAt(7)", s.charCodeAt(7)); + assertEq("s.charCodeAt(-1)", s.charCodeAt(-1)); + + Util.runKnownBug("string.code doesnt work", () -> { + assertEq('"f".code', "f".code); + assertEq('"o".code', "o".code); + assertEq('"1".code', "1".code); + assertEq('"b".code', "b".code); + assertEq('"a".code', "a".code); + assertEq('"r".code', "r".code); + assertEq('"foo".code', null); // multiple chars causes error + assertEq('"bar".code', null); // multiple chars causes error + }); + + Util.runKnownBug("String.fromCharCode doesnt work", () -> { + assertEq('String.fromCharCode(65)', String.fromCharCode(65)); + assertEq('String.fromCharCode(97)', String.fromCharCode(97)); + assertEq('String.fromCharCode(98)', String.fromCharCode(98)); + assertEq('String.fromCharCode(99)', String.fromCharCode(99)); + assertEq('String.fromCharCode(100)', String.fromCharCode(100)); + assertEq('String.fromCharCode(101)', String.fromCharCode(101)); + assertEq('String.fromCharCode(102)', String.fromCharCode(102)); + assertEq('String.fromCharCode(103)', String.fromCharCode(103)); + }); + + headerCode = ''; + + assertEq('("3" > "11")', ("3" > "11")); + assertEq('(" 3" < "3")', (" 3" < "3")); + assertEq('("a" < "b")', ("a" < "b")); + assertEq('("a" <= "b")', ("a" <= "b")); + assertEq('("a" > "b")', ("a" > "b")); + assertEq('("a" >= "b")', ("a" >= "b")); + + assertEq("'${5}'", '${5}'); + assertEq("'${5},${({})}'", '${5},${({})}'); + assertEq("'${5},${\"Hello\"}'", '${5},${"Hello"}'); + assertEq("'${5},${'Hello'}'", '${5},${'Hello'}'); + assertEq("'$${5}'", '$${5}'); + assertEq("'$${({})}'", '$${({})}'); + + assertEq('"$${5}"', "${5}"); + assertEq('"$${5},$${({})}"', "${5},${({})}"); + assertEq('"$${5},$${\\"Hello\\"}"', "${5},${\"Hello\"}"); + assertEq('"$${5},$${\'Hello\'}"', "${5},${'Hello'}"); + + } + + override function teardown() { + super.teardown(); + } +} \ No newline at end of file diff --git a/tests/src/tests/StringToolsCase.hx b/tests/src/tests/StringToolsCase.hx new file mode 100644 index 0000000..72f8c64 --- /dev/null +++ b/tests/src/tests/StringToolsCase.hx @@ -0,0 +1,25 @@ +package tests; + +using StringTools; + +class StringToolsCase extends TestCase { + override function setup() { + super.setup(); + } + + override function getNewInterp() { + var interp = super.getNewInterp(); + interp.variables.set("Std", Std); + interp.variables.set("String", String); + return interp; + } + + override function run() { + Util.runKnownBug("Using StringTools; not working", () -> { + }); + } + + override function teardown() { + super.teardown(); + } +} \ No newline at end of file diff --git a/tests/src/tests/TestCase.hx b/tests/src/tests/TestCase.hx index aa8f29a..bc0f41f 100644 --- a/tests/src/tests/TestCase.hx +++ b/tests/src/tests/TestCase.hx @@ -34,9 +34,11 @@ class TestCase { Util.assertNeq(execute(headerCode + script + tailCode), expected, message); } - public function execute(script:String) { + public function execute(script:String):Dynamic { var interp = clearPrevious ? getNewInterp() : this.interp; var expr = Util.parse(headerCode + script + tailCode); + if(expr == null) + return "ERROR"; if (clearPrevious) return interp.execute(expr); else