public void TestWithOneArray()
{
// We get memory corruption if we create the tree and use it, rather
// than writing it out to a file first. Not sure why... GC and other
// things looked at, but they don't seem to be variables.
{
var f = ROOTNET.NTFile.Open("TestWithOneArray.root", "RECREATE");
var tree = CreateTrees.CreateTreeWithSimpleSingleVector(50);
f.Write();
f.Close();
}
var f1 = ROOTNET.NTFile.Open("TestWithOneArray.root", "READ");
var tree1 = f1.Get("dude") as ROOTNET.NTTree;
var aa = new ArrayAnalyzer();
ROOTClassShell sh = new ROOTClassShell();
sh.Add(new classitem() { ItemType = "int[]", Name = "myvectorofint" });
var result = aa.DetermineAllArrayLengths(sh, tree1, 10);
Assert.AreEqual(10, result.Length, "# of events");
Assert.IsTrue(result.All(x => x.Length == 1), "incorrect individual variable list length list");
Assert.IsTrue(result.All(x => x[0].Item2 == 10), "incorrect individual variable list length list");
Assert.IsTrue(result.All(x => x[0].Item1 == "myvectorofint"), "incorrect individual variable list length list");
f1.Close();
}
public void test_THAT_array_expression_IS_valid()
{
var analyzer = new ArrayAnalyzer(null, null);
Expression <Func <SPListItem, object[]> > expr = (x => new [] { x["field1"], x["field2"] as Camlex.Asc, x["field3"] as Camlex.Desc });
Assert.That(analyzer.IsValid(expr), Is.True);
}
public void TestSingleGrouping()
{
/// Test the DetermineGroups that takes the simple argument
var rawData = new Tuple <string, int>[]
{
Tuple.Create("var1", 0),
Tuple.Create("var2", 10),
Tuple.Create("var3", 10),
Tuple.Create("var4", 0)
};
var aa = new ArrayAnalyzer();
var gp = aa.DetermineGroups(rawData).ToArray();
Assert.AreEqual(2, gp.Length, "# of groups");
var zero = (from g in gp where g.Item1 == 0 select g).First();
var ten = (from g in gp where g.Item1 == 10 select g).First();
Assert.AreEqual(2, zero.Item2.Length, "zero items");
Assert.AreEqual(2, ten.Item2.Length, "ten items");
Assert.IsTrue(zero.Item2[0] == "var1" || zero.Item2[0] == "var4", "zero item 0 name");
Assert.IsTrue(zero.Item2[1] == "var1" || zero.Item2[1] == "var4", "zero item 1 name");
Assert.IsTrue(ten.Item2[0] == "var2" || ten.Item2[0] == "var3", "ten item 0 name");
Assert.IsTrue(ten.Item2[1] == "var2" || ten.Item2[1] == "var3", "ten item 1 name");
}
public void TestGroupingSomeZeros()
{
/// 2 arrays in one group, and two with zeros all the time.
var aa = new ArrayAnalyzer();
var data = new Tuple <string, int>[][]
{
new Tuple <string, int>[] { Tuple.Create("var1", 5), Tuple.Create("var2", 5), Tuple.Create("var3", 2), Tuple.Create("var4", 0) },
new Tuple <string, int>[] { Tuple.Create("var1", 5), Tuple.Create("var2", 5), Tuple.Create("var3", 0), Tuple.Create("var4", 0) },
new Tuple <string, int>[] { Tuple.Create("var1", 5), Tuple.Create("var2", 5), Tuple.Create("var3", 0), Tuple.Create("var4", 0) }
};
var result = aa.DetermineGroups(data);
Assert.AreEqual(2, result.Count, "# of groups");
Assert.AreEqual(2, result[0].Variables.Length, "# of variables in group 1");
Assert.AreEqual(2, result[1].Variables.Length, "# of variables in group 2");
var ungroup = (from g in result where g.Name == "ungrouped" select g).First();
if (ungroup.Variables[0].NETName == "var3")
{
Assert.AreEqual("var4", ungroup.Variables[1].NETName);
}
else
{
Assert.AreEqual("var3", ungroup.Variables[1]);
}
}
public void TestArrayAndNormalItem()
{
var aa = new ArrayAnalyzer();
// We get memory corruption if we create the tree and use it, rather
// than writing it out to a file first. Not sure why... GC and other
// things looked at, but they don't seem to be variables.
{
var f = ROOTNET.NTFile.Open("TestArrayAndNormalItem.root", "RECREATE");
var tree = CreateTrees.CreateTreeWithSimpleSingleVectorAndItem(20);
f.Write();
f.Close();
}
var f1 = ROOTNET.NTFile.Open("TestArrayAndNormalItem.root", "READ");
var tree1 = f1.Get("dude") as ROOTNET.NTTree;
ROOTClassShell sh = new ROOTClassShell();
sh.Add(new Classitem()
{
ItemType = "int[]", Name = "myvectorofint"
});
var result = aa.DetermineAllArrayLengths(sh, tree1, 10);
Assert.AreEqual(10, result.Length, "# of events");
Assert.IsTrue(result.All(x => x.Length == 1), "incorrect individual variable list length list");
Assert.IsTrue(result.All(x => x[0].Item2 == 10), "incorrect individual variable list length list");
f1.Close();
}
private bool FillMultiDimensionalArrayProperty(MultiDimensionalArrayProperty property, InternalTypeInfo info,
object value)
{
if (property == null)
{
return(false);
}
property.ElementType = info.ElementType;
var analyzer = new ArrayAnalyzer(value);
// DimensionInfos
property.DimensionInfos = analyzer.ArrayInfo.DimensionInfos;
// Items
foreach (var indexSet in analyzer.GetIndexes())
{
var subValue = ((Array)value).GetValue(indexSet);
var itemProperty = CreateProperty(null, subValue);
property.Items.Add(new MultiDimensionalArrayItem(indexSet, itemProperty));
}
return(true);
}
private bool FillSingleDimensionalArrayProperty(SingleDimensionalArrayProperty property, InternalTypeInfo info,
object value)
{
if (property == null)
{
return(false);
}
property.ElementType = info.ElementType;
var analyzer = new ArrayAnalyzer(value);
// Dimensionen
var dimensionInfo = analyzer.ArrayInfo.DimensionInfos[0];
property.LowerBound = dimensionInfo.LowerBound;
// Items
foreach (var item in analyzer.GetValues())
{
var itemProperty = CreateProperty(null, item);
property.Items.Add(itemProperty);
}
return(true);
}
public void TestWithOneConstIndexedArray()
{
var aa = new ArrayAnalyzer();
string filename = "TestWithOneConstIndexedArray.root";
var f = new ROOTNET.NTFile(filename, "RECREATE");
var tree = CreateTrees.CreateTreeWithConstIndexedSimpleVector(20);
f.Write();
ROOTClassShell sh = new ROOTClassShell();
sh.Add(new Classitem()
{
ItemType = "int[]", Name = "arr"
});
var result = aa.DetermineAllArrayLengths(sh, tree, 10);
Assert.AreEqual(10, result.Length, "# of events");
Assert.IsTrue(result.All(x => x.Length == 1), "# of arrays");
Assert.IsTrue(result.All(x => x[0].Item2 == 20), "Length of array");
Assert.IsTrue(result.All(x => x[0].Item1 == "arr"), "variable name");
f.Close();
}
public void test_THAT_array_expression_with_guids_IS_valid()
{
var analyzer = new ArrayAnalyzer(null, null);
Expression <Func <SPListItem, object[]> > expr = (x => new[] { x[SPBuiltInFieldId.ContentTypeId], x["field2"] as Camlex.Asc, x[SPBuiltInFieldId.Modified] as Camlex.Desc });
Assert.That(analyzer.IsValid(expr), Is.True);
}
public void TestEmptyList()
{
ArrayList arr = new ArrayList();
Assert.Throws <ArgumentException>(() => {
double res = ArrayAnalyzer.SumOfMins(arr);
});
}
public void TestWithNoArrays()
{
var aa = new ArrayAnalyzer();
var tree = CreateTrees.CreateWithIntOnly(10);
ROOTClassShell sh = new ROOTClassShell();
var results = aa.DetermineAllArrayLengths(sh, tree, 10);
Assert.AreEqual(1, results.Length, "# of events incorrect");
Assert.AreEqual(0, results[0].Length, "found an array!?");
}
public void TestArrayWithNoEntries()
{
ArrayAnalyzer target = new ArrayAnalyzer(); // TODO: Initialize to an appropriate value
var tree = CreateTrees.CreateVectorTree();
ROOTClassShell sh = new ROOTClassShell();
target.DetermineAllArrayLengths(sh, tree, 10);
}
public void TestCorrectResult()
{
ArrayList arr = new ArrayList()
{
-27.39, 0, 5, -10.75, 15, 75.43, -11, -24, 14.87, 3, 21, 43, -50
};
double res = ArrayAnalyzer.SumOfMins(arr);
Assert.Equal(-77.39, res);
}
public void TestWithNoArrays()
{
var aa = new ArrayAnalyzer();
var tree = CreateTrees.CreateWithIntOnly(10);
ROOTClassShell sh = new ROOTClassShell();
var results = aa.DetermineAllArrayLengths(sh, tree, 10);
Assert.AreEqual(1, results.Length, "# of events incorrect");
Assert.AreEqual(0, results[0].Length, "found an array!?");
}
public void TestArrayWithNoEntries()
{
ArrayAnalyzer target = new ArrayAnalyzer(); // TODO: Initialize to an appropriate value
var tree = CreateTrees.CreateVectorTree();
ROOTClassShell sh = new ROOTClassShell();
target.DetermineAllArrayLengths(sh, tree, 10);
}
public void TestConsistBool()
{
ArrayList arr = new ArrayList()
{
5, 5.5, 0.344, -10, 15, -24.5, true
};
Assert.Throws <ArgumentException>(() => {
double res = ArrayAnalyzer.SumOfMins(arr);
});
}
public void TestConsistStr()
{
ArrayList arr = new ArrayList()
{
5, 5.5, 0.344, -10, "i'm_str", 7, -24.5
};
Assert.Throws <ArgumentException>(() => {
double res = ArrayAnalyzer.SumOfMins(arr);
});
}
public void TestNullGrouping()
{
/// No elements at all - like an empty ntuple with no arrays
var aa = new ArrayAnalyzer();
var data = new Tuple <string, int>[][]
{
new Tuple <string, int> [0]
};
var result = aa.DetermineGroups(data);
Assert.AreEqual(0, result.Count, "# of groups");
}
public void TestGroupingFourArraysTwoGroups()
{
var aa = new ArrayAnalyzer();
var data = new Tuple <string, int>[][]
{
new Tuple <string, int>[] { Tuple.Create("var1", 5), Tuple.Create("var2", 5), Tuple.Create("var3", 2), Tuple.Create("var4", 2) },
new Tuple <string, int>[] { Tuple.Create("var1", 5), Tuple.Create("var2", 5), Tuple.Create("var3", 8), Tuple.Create("var4", 8) },
new Tuple <string, int>[] { Tuple.Create("var1", 5), Tuple.Create("var2", 5), Tuple.Create("var3", 7), Tuple.Create("var4", 7) }
};
var result = aa.DetermineGroups(data);
Assert.AreEqual(2, result.Count, "# of groups");
Assert.AreEqual(2, result[0].Variables.Length, "# of variables in group 1");
Assert.AreEqual(2, result[1].Variables.Length, "# of variables in group 2");
}
public void test_THAT_array_expression_IS_determined_properly()
{
// arrange
Expression <Func <SPListItem, object[]> > expr = (x => new[] { x["field1"], x["field2"] as Camlex.Asc, x["field3"] as Camlex.Desc });
var operandBuilder = MockRepository.GenerateStub <IOperandBuilder>();
operandBuilder.Stub(b => b.CreateFieldRefOperandWithOrdering(null, null)).Return(null).IgnoreArguments();
var analyzer = new ArrayAnalyzer(null, operandBuilder);
// act
var operation = analyzer.GetOperation(expr);
//assert
Assert.That(operation, Is.InstanceOf <ArrayOperation>());
}
public void TestALotOfElements()
{
Random rand = new Random();
ArrayList arr = new ArrayList();
for (int i = 0; i < 100000000; i++)
{
arr.Add(rand.Next(0, 10000));
}
arr.Add(-2);
arr.Add(-2);
double res = ArrayAnalyzer.SumOfMins(arr);
Assert.Equal(-4, res);
}
public void TestGroupingTwoArraysEventualMismatch()
{
/// Start out in lock step, but then fall apart later in the sequence.
var aa = new ArrayAnalyzer();
var data = new Tuple <string, int>[][]
{
new Tuple <string, int>[] { Tuple.Create("var1", 5), Tuple.Create("var2", 5) },
new Tuple <string, int>[] { Tuple.Create("var1", 10), Tuple.Create("var2", 10) },
new Tuple <string, int>[] { Tuple.Create("var1", 10), Tuple.Create("var2", 4) }
};
var result = aa.DetermineGroups(data);
Assert.AreEqual(1, result.Count, "# of groups");
Assert.AreEqual("ungrouped", result[0].Name, "ungroued name incorrect");
Assert.AreEqual(2, result[0].Variables.Length, "# of variables in ungrouped");
}
public void TestGroupingOneArray()
{
/// A single array. Make sure it goes into ungrouped.
var aa = new ArrayAnalyzer();
var data = new Tuple <string, int>[][]
{
new Tuple <string, int>[] { Tuple.Create("var1", 5) },
new Tuple <string, int>[] { Tuple.Create("var1", 10) },
new Tuple <string, int>[] { Tuple.Create("var1", 4) }
};
var result = aa.DetermineGroups(data);
Assert.AreEqual(1, result.Count, "# of groups");
Assert.AreEqual("ungrouped", result[0].Name, "ungrouped name");
Assert.AreEqual(1, result[0].Variables.Length, "var count");
Assert.AreEqual("var1", result[0].Variables[0].NETName, "var name");
}
public void TestGroupingInitalZeros()
{
/// 2 arrays, both have zeros, but then have something good, should end up
/// in same group.
var aa = new ArrayAnalyzer();
var data = new Tuple <string, int>[][]
{
new Tuple <string, int>[] { Tuple.Create("var1", 0), Tuple.Create("var2", 0) },
new Tuple <string, int>[] { Tuple.Create("var1", 10), Tuple.Create("var2", 10) },
new Tuple <string, int>[] { Tuple.Create("var1", 10), Tuple.Create("var2", 10) }
};
var result = aa.DetermineGroups(data);
Assert.AreEqual(1, result.Count, "# of groups");
Assert.AreEqual(2, result[0].Variables.Length, "# of vars in group");
Assert.AreNotEqual("ungrouped", result[0].Name, "group name");
}
public void TestGroupingTwoArraysNoGroups()
{
/// Two arrays, that don't match at all (ungrouped)
var aa = new ArrayAnalyzer();
var data = new Tuple <string, int>[][]
{
new Tuple <string, int>[] { Tuple.Create("var1", 5), Tuple.Create("var2", 3) },
new Tuple <string, int>[] { Tuple.Create("var1", 10), Tuple.Create("var2", 9) },
new Tuple <string, int>[] { Tuple.Create("var1", 10), Tuple.Create("var2", 4) }
};
var result = aa.DetermineGroups(data);
Assert.AreEqual(1, result.Count, "# of groups");
Assert.AreEqual("ungrouped", result[0].Name, "ungroued name incorrect");
Assert.AreEqual(2, result[0].Variables.Length, "# of variables in ungrouped");
}
public void TestGroupingTwoArrays()
{
/// Two arrays, that are in lock step
/// A single array. Make sure it goes into ungrouped.
var aa = new ArrayAnalyzer();
var data = new Tuple <string, int>[][]
{
new Tuple <string, int>[] { Tuple.Create("var1", 5), Tuple.Create("var2", 5) },
new Tuple <string, int>[] { Tuple.Create("var1", 10), Tuple.Create("var2", 10) },
new Tuple <string, int>[] { Tuple.Create("var1", 10), Tuple.Create("var2", 10) }
};
var result = aa.DetermineGroups(data);
Assert.AreEqual(1, result.Count, "# of groups");
Assert.AreEqual(2, result[0].Variables.Length, "# of vars in group");
Assert.IsTrue((result[0].Variables[0].NETName == "var1" && result[0].Variables[1].NETName == "var2") ||
(result[0].Variables[0].NETName == "var2" && result[0].Variables[1].NETName == "var1"), "varable names");
}
public void TestSingleGrouping()
{
/// Test the DetermineGroups that takes the simple argument
var rawData = new Tuple<string, int>[]
{
Tuple.Create("var1", 0),
Tuple.Create("var2", 10),
Tuple.Create("var3", 10),
Tuple.Create("var4", 0)
};
var aa = new ArrayAnalyzer();
var gp = aa.DetermineGroups(rawData).ToArray();
Assert.AreEqual(2, gp.Length, "# of groups");
var zero = (from g in gp where g.Item1 == 0 select g).First();
var ten = (from g in gp where g.Item1 == 10 select g).First();
Assert.AreEqual(2, zero.Item2.Length, "zero items");
Assert.AreEqual(2, ten.Item2.Length, "ten items");
Assert.IsTrue(zero.Item2[0] == "var1" || zero.Item2[0] == "var4", "zero item 0 name");
Assert.IsTrue(zero.Item2[1] == "var1" || zero.Item2[1] == "var4", "zero item 1 name");
Assert.IsTrue(ten.Item2[0] == "var2" || ten.Item2[0] == "var3", "ten item 0 name");
Assert.IsTrue(ten.Item2[1] == "var2" || ten.Item2[1] == "var3", "ten item 1 name");
}
public void TestNullGrouping()
{
/// No elements at all - like an empty ntuple with no arrays
var aa = new ArrayAnalyzer();
var data = new Tuple<string, int>[][]
{
new Tuple<string, int>[0]
};
var result = aa.DetermineGroups(data);
Assert.AreEqual(0, result.Count, "# of groups");
}
public void TestWithOneConstIndexedArray()
{
var aa = new ArrayAnalyzer();
string filename = "TestWithOneConstIndexedArray.root";
var f = new ROOTNET.NTFile(filename, "RECREATE");
var tree = CreateTrees.CreateTreeWithConstIndexedSimpleVector(20);
f.Write();
ROOTClassShell sh = new ROOTClassShell();
sh.Add(new classitem() { ItemType = "int[]", Name = "arr" });
var result = aa.DetermineAllArrayLengths(sh, tree, 10);
Assert.AreEqual(10, result.Length, "# of events");
Assert.IsTrue(result.All(x => x.Length == 1), "# of arrays");
Assert.IsTrue(result.All(x => x[0].Item2 == 20), "Length of array");
Assert.IsTrue(result.All(x => x[0].Item1 == "arr"), "variable name");
f.Close();
}
public void TestGroupingInitalZeros()
{
/// 2 arrays, both have zeros, but then have something good, should end up
/// in same group.
var aa = new ArrayAnalyzer();
var data = new Tuple<string, int>[][]
{
new Tuple<string, int>[] { Tuple.Create("var1", 0), Tuple.Create("var2", 0)},
new Tuple<string, int>[] { Tuple.Create("var1", 10), Tuple.Create("var2", 10)},
new Tuple<string, int>[] { Tuple.Create("var1", 10), Tuple.Create("var2", 10)}
};
var result = aa.DetermineGroups(data);
Assert.AreEqual(1, result.Count, "# of groups");
Assert.AreEqual(2, result[0].Variables.Length, "# of vars in group");
Assert.AreNotEqual("ungrouped", result[0].Name, "group name");
}
public void TestGroupingTwoArrays()
{
/// Two arrays, that are in lock step
/// A single array. Make sure it goes into ungrouped.
var aa = new ArrayAnalyzer();
var data = new Tuple<string, int>[][]
{
new Tuple<string, int>[] { Tuple.Create("var1", 5), Tuple.Create("var2", 5)},
new Tuple<string, int>[] { Tuple.Create("var1", 10), Tuple.Create("var2", 10)},
new Tuple<string, int>[] { Tuple.Create("var1", 10), Tuple.Create("var2", 10)}
};
var result = aa.DetermineGroups(data);
Assert.AreEqual(1, result.Count, "# of groups");
Assert.AreEqual(2, result[0].Variables.Length, "# of vars in group");
Assert.IsTrue((result[0].Variables[0].NETName == "var1" && result[0].Variables[1].NETName == "var2")
|| (result[0].Variables[0].NETName == "var2" && result[0].Variables[1].NETName == "var1"), "varable names");
}
public void TestGroupingOneArray()
{
/// A single array. Make sure it goes into ungrouped.
var aa = new ArrayAnalyzer();
var data = new Tuple<string, int>[][]
{
new Tuple<string, int>[] { Tuple.Create("var1", 5)},
new Tuple<string, int>[] { Tuple.Create("var1", 10)},
new Tuple<string, int>[] { Tuple.Create("var1", 4)}
};
var result = aa.DetermineGroups(data);
Assert.AreEqual(1, result.Count, "# of groups");
Assert.AreEqual("ungrouped", result[0].Name, "ungrouped name");
Assert.AreEqual(1, result[0].Variables.Length, "var count");
Assert.AreEqual("var1", result[0].Variables[0].NETName, "var name");
}
public void TestGroupingSomeZeros()
{
/// 2 arrays in one group, and two with zeros all the time.
var aa = new ArrayAnalyzer();
var data = new Tuple<string, int>[][]
{
new Tuple<string, int>[] { Tuple.Create("var1", 5), Tuple.Create("var2", 5), Tuple.Create("var3", 2), Tuple.Create("var4", 0)},
new Tuple<string, int>[] { Tuple.Create("var1", 5), Tuple.Create("var2", 5), Tuple.Create("var3", 0), Tuple.Create("var4", 0)},
new Tuple<string, int>[] { Tuple.Create("var1", 5), Tuple.Create("var2", 5), Tuple.Create("var3", 0), Tuple.Create("var4", 0)}
};
var result = aa.DetermineGroups(data);
Assert.AreEqual(2, result.Count, "# of groups");
Assert.AreEqual(2, result[0].Variables.Length, "# of variables in group 1");
Assert.AreEqual(2, result[1].Variables.Length, "# of variables in group 2");
var ungroup = (from g in result where g.Name == "ungrouped" select g).First();
if (ungroup.Variables[0].NETName == "var3")
Assert.AreEqual("var4", ungroup.Variables[1].NETName);
else
Assert.AreEqual("var3", ungroup.Variables[1]);
}
public void TestGroupingTwoArraysEventualMismatch()
{
/// Start out in lock step, but then fall apart later in the sequence.
var aa = new ArrayAnalyzer();
var data = new Tuple<string, int>[][]
{
new Tuple<string, int>[] { Tuple.Create("var1", 5), Tuple.Create("var2", 5)},
new Tuple<string, int>[] { Tuple.Create("var1", 10), Tuple.Create("var2", 10)},
new Tuple<string, int>[] { Tuple.Create("var1", 10), Tuple.Create("var2", 4)}
};
var result = aa.DetermineGroups(data);
Assert.AreEqual(1, result.Count, "# of groups");
Assert.AreEqual("ungrouped", result[0].Name, "ungroued name incorrect");
Assert.AreEqual(2, result[0].Variables.Length, "# of variables in ungrouped");
}
public void TestGroupingTwoArraysNoGroups()
{
/// Two arrays, that don't match at all (ungrouped)
var aa = new ArrayAnalyzer();
var data = new Tuple<string, int>[][]
{
new Tuple<string, int>[] { Tuple.Create("var1", 5), Tuple.Create("var2", 3)},
new Tuple<string, int>[] { Tuple.Create("var1", 10), Tuple.Create("var2", 9)},
new Tuple<string, int>[] { Tuple.Create("var1", 10), Tuple.Create("var2", 4)}
};
var result = aa.DetermineGroups(data);
Assert.AreEqual(1, result.Count, "# of groups");
Assert.AreEqual("ungrouped", result[0].Name, "ungroued name incorrect");
Assert.AreEqual(2, result[0].Variables.Length, "# of variables in ungrouped");
}
public void TestGroupingFourArraysTwoGroups()
{
var aa = new ArrayAnalyzer();
var data = new Tuple<string, int>[][]
{
new Tuple<string, int>[] { Tuple.Create("var1", 5), Tuple.Create("var2", 5), Tuple.Create("var3", 2), Tuple.Create("var4", 2)},
new Tuple<string, int>[] { Tuple.Create("var1", 5), Tuple.Create("var2", 5), Tuple.Create("var3", 8), Tuple.Create("var4", 8)},
new Tuple<string, int>[] { Tuple.Create("var1", 5), Tuple.Create("var2", 5), Tuple.Create("var3", 7), Tuple.Create("var4", 7)}
};
var result = aa.DetermineGroups(data);
Assert.AreEqual(2, result.Count, "# of groups");
Assert.AreEqual(2, result[0].Variables.Length, "# of variables in group 1");
Assert.AreEqual(2, result[1].Variables.Length, "# of variables in group 2");
}
/// <summary>
/// Look at everything we have in this tree and see if we can't generate a class correctly.
/// </summary>
/// <param name="tree"></param>
/// <returns></returns>
public IEnumerable<ROOTClassShell> GenerateClasses(ROOTNET.Interface.NTTree tree)
{
if (tree == null)
throw new ArgumentNullException("tree must not be null");
///
/// The outlying class is going to be called by the name of the tree.
///
var masterClass = new ROOTClassShell(tree.Name);
var subClassesByName = from sc in ExtractClassesFromBranchList(masterClass, tree.ListOfBranches.Cast<ROOTNET.Interface.NTBranch>())
group sc by sc.Name;
var subClasses = from scg in subClassesByName
where scg.ClassesAreIdnetical()
select scg.First();
foreach (var sc in subClasses)
{
yield return sc;
}
///
/// Last thing we need to do is create a proxy for the class.
///
FileInfo f = MakeProxy(tree);
masterClass.NtupleProxyPath = f.FullName;
///
/// Work around a ROOT bug that doesn't allow for unloading of classes
/// in the STL after a query is run. Actually, it will unload them, but somehow keeps
/// references in memory.
///
masterClass.ClassesToGenerate = ExtractSTLDictionaryReferences(f);
///
/// Analyze the TTree arrays.
///
var at = new ArrayAnalyzer();
var groupInfo = at.AnalyzeTTree(masterClass, tree, 100);
///
/// Any item that isn't an array should be added to the list and
/// put in the "ungrouped" array.
///
AddNonArrays(masterClass, groupInfo, "ungrouped");
///
/// Write out the user info
///
masterClass.UserInfoPath = WriteUserInfo(groupInfo, tree.SanitizedName()).FullName;
///
/// Return the master class
///
yield return masterClass;
}
public void TestNull()
{
Assert.Throws <ArgumentNullException>(() => {
double res = ArrayAnalyzer.SumOfMins(null);
});
}
