Added a lot more tests
This commit is contained in:
NeeEoo
+13
-1
@@ -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
|
||||
}
|
||||
|
||||
+16
-3
@@ -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;
|
||||
}
|
||||
|
||||
@@ -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<Int> = cast new haxe.ds.Vector<Int>(size.width);
|
||||
|
||||
for (time in times) {
|
||||
var index:Int = Std.int((time - times[0]) / (collumRange / size.width));
|
||||
counts[index]++;
|
||||
}
|
||||
|
||||
var normalizedCounts:Array<Float> = [for (count in counts) count / times.length];
|
||||
var gridFilling:Array<Int> = [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<Float> = [];
|
||||
|
||||
for (i in 0...10000)
|
||||
array.push(Math.random());
|
||||
}
|
||||
public function benchmark() {}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
@@ -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();
|
||||
}
|
||||
}
|
||||
@@ -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();
|
||||
}
|
||||
}
|
||||
@@ -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();
|
||||
}
|
||||
}
|
||||
@@ -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();
|
||||
}
|
||||
}
|
||||
@@ -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();
|
||||
}
|
||||
}
|
||||
@@ -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();
|
||||
}
|
||||
}
|
||||
@@ -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();
|
||||
}
|
||||
}
|
||||
@@ -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();
|
||||
}
|
||||
}
|
||||
@@ -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();
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
|
||||
Reference in New Issue
Block a user