Squashed 'cloner/' content from commit 79ff709

git-subtree-dir: cloner
git-subtree-split: 79ff709d0060b967d3508b6abfe194bedfb63f1b

cloner/test/TestCloner.hx

@@ -0,0 +1,94 @@
+import classes.ClassTypeProperty;
+import classes.ABCEnum;
+import cloner.Cloner;
+import classes.ArrayProperty;
+import classes.ClassProperty;
+import classes.BoolProperty;
+import classes.NullClass;
+class TestCloner extends haxe.unit.TestCase {
+
+    var cloner:Cloner;
+
+    override public function setup() {
+        cloner = new Cloner();
+    }
+
+    public function testclone() {
+        var value:NullClass = new NullClass();
+        assertTrue(cloner.clone(value) != null);
+    }
+
+    public function testBoolProperty() {
+        var value:BoolProperty = new BoolProperty(true);
+        assertTrue(cloner.clone(value).property);
+    }
+
+    public function testArrayProperty() {
+        var value:ArrayProperty = new ArrayProperty([true]);
+        assertTrue(cloner.clone(value).property[0]);
+    }
+
+    public function testStringMap():Void {
+        var value:Map<String, Int> = new Map<String, Int>();
+        value.set('you',1);
+        assertTrue(cloner.clone(value).get('you') == 1);
+    }
+
+    public function testIntMap():Void {
+        var value:Map<Int, Int> = new Map<Int, Int>();
+        value.set(1,2);
+        assertTrue(cloner.clone(value).get(1) == 2);
+    }
+
+    public function testObjectsInMap():Void {
+        var value:Map<Int, NullClass> = new Map<Int, NullClass>();
+        var v:NullClass = new NullClass();
+        value.set(1,v);
+        assertTrue(cloner.clone(value).get(1) != v);
+    }
+
+    public function testString():Void {
+        assertTrue(cloner.clone('a') == 'a');
+    }
+
+    public function testClassType():Void {
+        assertTrue(cloner.clone(NullClass) == NullClass);
+    }
+
+    public function testEnum():Void {
+        assertTrue(cloner.clone(ABCEnum.b) == ABCEnum.b);
+    }
+
+    public function testClassProperty():Void {
+        var value:ClassProperty = new ClassProperty();
+        var inValue = new BoolProperty(true);
+        value.property = inValue;
+        var outValue:BoolProperty = cloner.clone(value).property;
+        assertTrue(outValue.property);
+        assertFalse(inValue == outValue);
+    }
+
+    public function testAnonObjectAreDifferentCopies():Void {
+        var value = { a: 10, b: 20 };
+        var clone = cloner.clone(value);
+        Reflect.setField(value, 'a', 33);
+        assertEquals(10, Reflect.getProperty(clone, 'a'));
+    }
+
+    public function testEmbededAnonObject():Void {
+        var inner = {b: 5};
+        var value = { a: 10, inner: inner };
+        var clone = cloner.clone(value);
+        Reflect.setField(inner, 'b', 33);
+
+        var cloneInner = Reflect.getProperty(clone, 'inner');
+        assertEquals(5, Reflect.getProperty(cloneInner, 'b'));
+    }
+
+    public function testClassRefInsideAnObj():Void {
+        var value:ClassTypeProperty = new ClassTypeProperty();
+        value.property = BoolProperty;
+        var outValue:ClassTypeProperty = cloner.clone(value);
+        assertEquals(outValue.property, BoolProperty);
+    }
+}

cloner/test/TestClonerCache.hx

@@ -0,0 +1,35 @@
+import cloner.Cloner;
+import classes.ClassProperty;
+import classes.BoolProperty;
+class TestClonerCache extends haxe.unit.TestCase {
+
+    var cloner:Cloner;
+    var input:Array<ClassProperty>;
+    var outcome:Array<ClassProperty>;
+
+    override public function setup() {
+        cloner = new Cloner();
+    }
+
+    public function testReferences():Void {
+        setupOutcomeWithReferences();
+        assertTrue(outcome[0].property == outcome[1].property);
+    }
+
+    public function testNoSideEffects():Void {
+        setupOutcomeWithReferences();
+        outcome[0].property = true;
+        outcome = cloner.clone(input);
+        assertFalse(outcome[0].property);
+    }
+
+    function setupOutcomeWithReferences():Void {
+        var a:ClassProperty = new ClassProperty();
+        var b:ClassProperty = new ClassProperty();
+        var c:BoolProperty = new BoolProperty();
+        a.property = c;
+        b.property = c;
+        input = [a, b];
+        outcome = cloner.clone(input);
+    }
+}

cloner/test/TestMain.hx

@@ -0,0 +1,11 @@
+import haxe.unit.TestRunner;
+class TestMain {
+
+    static function main() {
+        var runner:TestRunner = new TestRunner();
+        runner.add(new TestCloner());
+        runner.add(new TestClonerCache());
+        runner.run();
+    }
+
+}

cloner/test/classes/ABCEnum.hx

@@ -0,0 +1,6 @@
+package classes;
+enum ABCEnum {
+    a;
+    b;
+    c;
+}

cloner/test/classes/ArrayProperty.hx

@@ -0,0 +1,7 @@
+package classes;
+class ArrayProperty {
+    public var property:Array<Bool>;
+    public function new(v:Array<Bool>):Void {
+        property = v;
+    }
+}

cloner/test/classes/BoolProperty.hx

@@ -0,0 +1,7 @@
+package classes;
+class BoolProperty {
+    public var property:Bool;
+    public function new(v:Bool=false):Void {
+        property = v;
+    }
+}

cloner/test/classes/ClassProperty.hx

@@ -0,0 +1,5 @@
+package classes;
+class ClassProperty {
+    public var property:Dynamic;
+    public function new():Void {}
+}

cloner/test/classes/ClassTypeProperty.hx

@@ -0,0 +1,5 @@
+package classes;
+class ClassTypeProperty {
+    public var property:Class<Dynamic>;
+    public function new():Void {}
+}

cloner/test/classes/NullClass.hx

@@ -0,0 +1,4 @@
+package classes;
+class NullClass {
+    public function new():Void {}
+}

cloner/test/compile.hxml

@@ -0,0 +1,15 @@
+-cp .
+-cp ../src
+-lib hx3compat
+-main TestMain
+-debug
+-cpp ../bin/test
+
+--next
+
+-cp .
+-cp ../src
+-lib hx3compat
+-main TestMain
+-debug
+-neko ../bin/test/TestMain.n