Added some needed tests to core classes

PicNet · Sep 11, 2013 · 7e65b97 · 7e65b97
1 parent 7a56e97
commit 7e65b97
Show file tree

Hide file tree

Showing 12 changed files with 427 additions and 108 deletions.
diff --git a/PicNetML.Tests/HelpersTests.cs b/PicNetML.Tests/HelpersTests.cs
@@ -1,8 +1,17 @@
 using System;
+using System.IO;
+using System.Linq;
 using NUnit.Framework;
+using PicNetML.Arff;
 
 namespace PicNetML.Tests {
-  [TestFixture] public class HelpersTests {
+  [TestFixture]
+  public class HelpersTests
+  {
+    [SetUp, TearDown] public void RemoveWorkingFiles() {
+      Directory.GetFiles(".", "*.obj").ForEach2(File.Delete);
+    }
+
     [Test] public void test_range_with_positive_step_functions() {
       var actual = Helpers.Range(0.1m, 0.3m, 0.1m);
       CollectionAssert.AreEqual(new [] {0.1m, 0.2m, 0.3m}, actual, "Actual: " + String.Join(", ", actual));
@@ -19,5 +28,166 @@ [Test] public void test_range_arg_valudation() {
       Assert.Throws(typeof(ArgumentOutOfRangeException), () => Helpers.Range(0.1m, 0.3m, -0.1m));
       Assert.Throws(typeof(ArgumentOutOfRangeException), () => Helpers.Range(0.3m, 0.3m, -0.1m));
     }
-  }
+
+    [Test] public void test_serialisation_and_deserialisation()
+    {
+      var file = "test.obj";
+      var o = new SerialisationObj();
+      var serialised = Helpers.Serialise(o, file);
+      var deserialised = Helpers.Deserialise<SerialisationObj>(file);
+
+      Assert.AreEqual(o, serialised);
+
+      Assert.AreNotEqual(o, deserialised);
+      Assert.AreEqual(o.p, deserialised.p);
+    }
+
+    [Test] public void test_get_or_serialise_functionality()
+    {
+      var file = "test.obj";
+      var o = new SerialisationObj();
+      var count = 0;
+      Func<SerialisationObj> creater = () => {
+        count++;
+        return o;
+      };
+      var created = Helpers.GetOrSetSerialised(file, creater);
+      var deserialised = Helpers.GetOrSetSerialised(file, creater);
+      Assert.AreEqual(1, count);
+      Assert.AreEqual(o, created);
+
+      Assert.AreNotEqual(o, deserialised);
+      Assert.AreEqual(o.p, deserialised.p);
+    }
+
+    [Test] public void test_get_value_on_simple_objects()
+    {
+      var s = new SimpleObj { p = "p1" };
+      Assert.AreEqual("p1", Helpers.GetValue<string>(s, "p"));
+      Assert.AreEqual("p1", Helpers.GetValue(s, "p"));
+    }
+
+    [Test] public void test_get_value_on_igetvalue_objects()
+    {
+      var s = new IGetValueObj();
+      Assert.AreEqual("p1", Helpers.GetValue<string>(s, "p"));
+      Assert.AreEqual("p1", Helpers.GetValue(s, "p"));
+    }
+
+    [Test] public void test_get_value_on_extendable_objects()
+    {
+      var ex = ExtendableObj.Create(new SimpleObj { p = "p1" });
+      ex.AddString("p2", "v2");
+
+      Assert.AreEqual("p1", Helpers.GetValue<string>(ex, "p"));
+      Assert.AreEqual("p1", Helpers.GetValue(ex, "p"));
+      Assert.AreEqual("v2", Helpers.GetValue<string>(ex, "p2"));
+      Assert.AreEqual("v2", Helpers.GetValue(ex, "p2"));
+    }
+
+    [Test] public void test_set_value_on_simple_objects()
+    {
+      var s = new SimpleObj { p = "p1" };
+      Helpers.SetValue(s, "p", "p2");
+
+      Assert.AreEqual("p2", s.p);
+      Assert.AreEqual("p2", Helpers.GetValue<string>(s, "p"));
+      Assert.AreEqual("p2", Helpers.GetValue(s, "p"));
+    }
+
+    [Test] public void test_set_value_on_extendable_objects()
+    {
+      var ex = ExtendableObj.Create(new SimpleObj { p = "p1" });
+      ex.AddString("p2", "v2");
+
+      Helpers.SetValue(ex, "p", "p2");
+      Helpers.SetValue(ex, "p2", "v3");
+
+      Assert.AreEqual("p2", ex.BaseObject.p);
+      Assert.AreEqual("p2", Helpers.GetValue<string>(ex, "p"));
+      Assert.AreEqual("p2", Helpers.GetValue(ex, "p"));
+
+      Assert.AreEqual("v3", Helpers.GetValue<string>(ex, "p2"));
+      Assert.AreEqual("v3", Helpers.GetValue(ex, "p2"));
+    }
+
+    [Test] public void test_rows_where_prop_is_value_functionality()
+    {
+      var rows = new [] {
+        new SimpleObj { p = "1" },
+        new SimpleObj { p = "2" },
+        new SimpleObj { p = "2" },
+        new SimpleObj { p = "3" },
+      };
+      var result = Helpers.RowsWherePropIsValue(rows, "p", "2");
+      CollectionAssert.AreEqual(new [] {rows[1], rows[2]}, result);
+    }
+
+    [Test] public void test_get_props_on_simple_objects()
+    {
+      var names = Helpers.GetProps(typeof(SimpleObj)).Select(p => p.Name).ToArray();
+      Assert.AreEqual(new [] {"p"}, names);
+    }
+
+    [Test] public void test_get_props_on_extendable_objects_gets_from_base_type()
+    {
+      var names = Helpers.GetProps(typeof(ExtendableObj<SimpleObj>)).Select(p => p.Name).ToArray();
+      Assert.AreEqual(new [] {"p"}, names);
+    }
+
+    [Test] public void test_cloning_on_simple_objs()
+    {
+      var s = new SimpleObj {p ="v"};
+      var cloned = Helpers.Clone(s);
+      Assert.AreNotEqual(s, cloned);
+      Assert.AreEqual(s.p, cloned.p);
+    }
+
+    [Test] public void test_cloning_on_icloneables()
+    {
+      var c = new CloneableObj {p =100};
+      var cloned = Helpers.Clone(c);
+      Assert.AreEqual(100, c.p);
+      Assert.AreEqual(101, cloned.p);
+    }
+
+    [Test] public void test_cloning_on_extendables_with_simple_base()
+    {
+      var s = new SimpleObj {p ="v"};
+      var ex = ExtendableObj.Create(s);
+      ex.AddString("p2", "v2");
+      var cloned = Helpers.Clone(ex);
+
+      Assert.AreNotEqual(ex, cloned);
+      Assert.AreEqual(ex.GetValue("p"), cloned.GetValue("p"));
+      Assert.AreEqual(ex.GetValue("p2"), cloned.GetValue("p2"));
+    }
+
+    [Test] public void test_cloning_on_extendables_with_clonable_base()
+    {
+      var c = new CloneableObj {p =100};
+      var ex = ExtendableObj.Create(c);
+      ex.AddString("p2", "v2");
+      var cloned = Helpers.Clone(ex);
+
+      Assert.AreNotEqual(ex, cloned);
+      Assert.AreEqual(100, ex.GetValue("p"));
+      Assert.AreEqual(101, cloned.GetValue("p"));
+      Assert.AreEqual(ex.GetValue("p2"), cloned.GetValue("p2"));
+    }
+
+    [Serializable] class SerialisationObj { public string p = "property value"; } 
+    class SimpleObj { public string p {get;set;} } }
+    class IGetValueObj : IGetValue { 
+      public object GetValue(string property) {
+        if (property == "p") return "p1";
+        throw new ArgumentException("property");
+      }
+    }     
+    class CloneableObj : ICloneable {
+      public int p {get;set;}
+      public object Clone() {
+        return new CloneableObj { p = p + 1 };
+      }
+    }
 }
diff --git a/PicNetML.Tests/IEnumerableExtensionsTests.cs b/PicNetML.Tests/IEnumerableExtensionsTests.cs
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using java.util;
+using PicNetML;
+using NUnit.Framework;
+namespace PicNetML.Tests
+{
+  [TestFixture] public class IEnumerableExtensionsTests
+  {
+    [Test] public void test_GetMajority()
+    {
+      var possibilities = new [] {"a", "b", "c", "b", "c", "b"};
+      Assert.AreEqual("b", possibilities.GetMajority());
+    }
+
+    [Test] public void test_Randomize()
+    {
+      var l = new [] {1, 2, 3, 4, 5};
+      var rnd = l.Randomize().ToArray();
+      CollectionAssert.AreNotEqual(l, rnd);
+      CollectionAssert.AreEqual(l, rnd.OrderBy(v => v));
+    }
+
+    [Test] public void test_RandomSample()
+    {
+      var l = new [] {1, 2, 3, 4, 5};
+      var rnd = l.RandomSample(2);
+      var rnd2 = l.RandomSample(5).ToArray();
+
+      Assert.AreEqual(2, rnd.Count());
+      CollectionAssert.AreNotEqual(l, rnd2);
+      CollectionAssert.AreEqual(l, rnd2.OrderBy(v => v));
+    }
+
+    [Test] public void test_RandomSampleWithReplacement()
+    {
+      var l = new [] {1, 2, 3, 4, 5};
+      var rnd = l.RandomSampleWithReplacement(2);
+      var rnd2 = l.RandomSampleWithReplacement(5).ToArray();
+
+      Assert.AreEqual(2, rnd.Count());
+      CollectionAssert.AreNotEqual(l, rnd2);
+      CollectionAssert.AreNotEqual(l, rnd2.OrderBy(v => v));
+    }
+
+    [Test] public void test_ToArrayList()
+    {
+      var l = new [] {1, 2, 3, 4, 5};
+      var al = l.ToArrayList();
+      Assert.AreEqual(typeof(ArrayList), al.GetType());
+      CollectionAssert.AreEqual(l, al);
+    }
+
+    [Test] public void test_ForEach2()
+    {
+      var l = new [] {1, 2, 3, 4, 5};
+      var l2 = new List<int>();
+      l.ForEach2(v => l2.Add(v * 2));
+      CollectionAssert.AreEqual(new [] {2, 4, 6, 8, 10}, l2);
+    }
+
+    [Test] public void test_ForEach2_witj_index()
+    {
+      var l = new [] {1, 2, 3, 4, 5};
+      var l2 = new List<int>();
+      l.ForEach2((v,i) => l2.Add(v + i));
+      CollectionAssert.AreEqual(new [] {1, 3, 5, 7, 9}, l2);
+    }
+
+    [Test] public void test_ToEnumerable()
+    {
+      var al = new ArrayList();
+      al.add(1); al.add(2); al.add(3);
+      var l = al.ToEnumerable<int>();
+      CollectionAssert.AreEqual(new [] {1, 2, 3}, l);
+    }
+  }
+}
diff --git a/PicNetML.Tests/PicNetML.Tests.csproj b/PicNetML.Tests/PicNetML.Tests.csproj
@@ -99,6 +99,7 @@
     <Compile Include="Clstr\BasicClustererTests.cs" />
     <Compile Include="Fltr\BasicFilteringTests.cs" />
     <Compile Include="HelpersTests.cs" />
+    <Compile Include="IEnumerableExtensionsTests.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="RuntimeHelpers\AttributesRemoverTests.cs" />
     <Compile Include="TestUtils\TestingHelpers.cs" />

diff --git a/PicNetML/CombinationRuntimeBuilder.cs b/PicNetML/CombinationRuntimeBuilder.cs
@@ -5,16 +5,17 @@
 
 namespace PicNetML
 {
+  // TODO: Implement fully or remove.
   internal class CombinationRuntimeBuilder<T> where T : new()
   {
-    private readonly int classifier;
+    private readonly int classidx;
     private readonly T[] data;
     private readonly string[][] props;
     private readonly int degrees;
 
-    public CombinationRuntimeBuilder(int classifier, T[] data, int[] indexes, int degrees) {
+    public CombinationRuntimeBuilder(int classidx, T[] data, int[] indexes, int degrees) {
       if (degrees != 3) throw new ArgumentException("Only 3 degrees currently supported.", "degrees");      
-      this.classifier = classifier;
+      this.classidx = classidx;
       this.data = data;      
       this.degrees = degrees;
 
@@ -45,7 +46,7 @@ public Runtime CreateRuntime() {
         return ext;
       }).ToArray();
       Console.WriteLine("Created Extended array");
-      return Runtime.LoadFromRows(classifier, extended);
+      return Runtime.LoadFromRows(classidx, extended);
     }
 
     private ICollection<string[]> GetAdditionalProperties(string[] startprops) {

diff --git a/PicNetML/ExtendableObj.cs b/PicNetML/ExtendableObj.cs
@@ -32,19 +32,28 @@ internal ICollection<object> GetExtendedPropertiesValues() {
       return Properties.Select(p => p.Value).ToArray(); 
     }
 
+    public bool HasExtendedProperty(string name) {
+      return namevalmap.ContainsKey(name);
+    }
+
     public object GetValue(string name) { 
       return base_obj_keys.ContainsKey(name) ? 
           Helpers.GetValue(BaseObjectObj, name) : 
           namevalmap[name].Item2;
     }
 
+    public void SetValue(string name, object value) { 
+      if (base_obj_keys.ContainsKey(name)) Helpers.SetValue(BaseObjectObj, name, value);
+      else namevalmap[name] = Tuple.Create(namevalmap[name].Item1, value);
+    }
+
     public void AddProperty(string name, EAttributeType type, object value) {
       namevalmap.Add(name, Tuple.Create(type, value));
       Properties.Add(new ExtendedProperty { Type = type, Name = name, Value = value });
     }
   }
 
-  [Serializable] public class ExtendableObj<T> : ExtendableObjBase, IExtendableObj<T> where T : new() {            
+  [Serializable] public class ExtendableObj<T> : ExtendableObjBase, ICloneable, IExtendableObj<T> where T : new() {            
     public ExtendableObj() { throw new ApplicationException("Create ExtendableObj using ExtendableObj.Create."); }
 
     internal ExtendableObj(T t) { 
@@ -79,12 +88,13 @@ public ExtendableObj<T> AddDate(string name, DateTime value) {
       return this;
     }    
 
-    public object Clone() { 
-      var cloned = new ExtendableObj<T> {
-        Properties = Properties.ToArray(), 
-        BaseObject = (T) (BaseObject is ICloneable ? 
-            ((ICloneable) BaseObject).Clone() : BaseObject)
-      };
+    public object Clone() {
+      Console.WriteLine("HERE");
+      var props = Properties.ToArray();
+      var baseo = BaseObject is ICloneable ? 
+            ((ICloneable) BaseObject).Clone() : BaseObject;
+      var cloned = new ExtendableObj<T>((T) baseo);
+      props.ForEach2(p => cloned.AddProperty(p.Name, p.Type, p.Value));      
       return cloned;
     }
 

diff --git a/PicNetML/Helpers.cs b/PicNetML/Helpers.cs
@@ -45,15 +45,18 @@ public static T GetOrSetSerialised<T>(string file, Func<T> loader) {
     }
 
     public static object GetValue(object o, string prop) {
-      if (o is IExtendableObj<object>) o = ((IExtendableObj<object>)o).BaseObject;
       return o is IGetValue ? 
           ((IGetValue) o).GetValue(prop) : 
           o.GetType().GetProperty(prop).GetValue(o);
     }
 
     public static void SetValue(object target, string prop, object value) {
-      if (target is IExtendableObj<object>) target = ((IExtendableObj<object>)target).BaseObject;
-      target.GetType().GetProperty(prop).SetValue(target, value);
+      if (target is ExtendableObjBase) {
+        var ex = (ExtendableObjBase) target;
+        ex.SetValue(prop, value);
+      } else {
+        target.GetType().GetProperty(prop).SetValue(target, value);
+      }
     }
 
     public static IEnumerable<T> RowsWherePropIsValue<T>(IEnumerable<T> data, string prop, object value) {