public void SampleRectangularArrayToStringTest()
{
List <String> resultStrings = new List <string> {
"A1,A2,A3", "{A1,A2,A3},{B1,B2,B3},{C1,C2,C3}", "{{A1,A2},{B1,B2}},{{C1,C2},{D1,D2}}"
};
Array rectangularArray1D = new string[] { "A1", "A2", "A3" };
Array rectangularArray2D = new string[, ] {
{ "A1", "A2", "A3" }, { "B1", "B2", "B3" }, { "C1", "C2", "C3" }
};
Array rectangularArray3D = new string[, , ] {
{ { "A1", "A2" }, { "B1", "B2" } }, { { "C1", "C2" }, { "D1", "D2" } }
};
var arrays = new List <Array>()
{
rectangularArray1D, rectangularArray2D, rectangularArray3D
};
foreach (var array in arrays)
{
var outerProduct = new OuterProductIndexGenerator(array);
var processor = new RectangularArrayToString(array);
outerProduct.ProcessOuterProduct(processor);
//System.Console.WriteLine (processor.Result.ToString());
string result = processor.Result.ToString();
Assert.That(new List <String> {
result
}, Is.SubsetOf(resultStrings));
}
}
public void NumberElementsPerDimensionCtorTest()
{
int[] arrayDimensions = new int[] { 5, 7, 11 };
var outerProduct = new OuterProductIndexGenerator(arrayDimensions);
Assert.That(outerProduct.Length, Is.EqualTo(5 * 7 * 11));
}
public void ArrayCtorTest()
{
String[,] rectangularArray = new string[, ] {
{ "A1", "A2" }, { "B1", "B2" }, { "C1", "C2" }
};
var outerProduct = new OuterProductIndexGenerator(rectangularArray);
Assert.That(outerProduct.Length, Is.EqualTo(3 * 2));
}
public void PermutationVisitorTest()
{
var dimensionArray = new int[] { 2, 3, 2 };
var outerProduct = new OuterProductIndexGenerator(dimensionArray);
var processor = new OuterProductProcessorOneLineString(null);
outerProduct.ProcessOuterProduct(processor);
string s = processor.GetResult();
Assert.That(s, Is.EqualTo("{{(0,0,0),(0,0,1)},{(0,1,0),(0,1,1)},{(0,2,0),(0,2,1)}},{{(1,0,0),(1,0,1)},{(1,1,0),(1,1,1)},{(1,2,0),(1,2,1)}}"));
}
public void RectangularArrayVisitorTest()
{
String[,] rectangularArray = new string[, ] {
{ "A1", "A2", "A3" }, { "B1", "B2", "B3" }, { "C1", "C2", "C3" }
};
var outerProduct = new OuterProductIndexGenerator(rectangularArray);
var processor = new OuterProductProcessorArrayPrinter(rectangularArray);
outerProduct.ProcessOuterProduct(processor);
string result = processor.GetResult();
Assert.That(result, Is.EqualTo("{A1,A2,A3},{B1,B2,B3},{C1,C2,C3}"));
}
public void VisitorNestedForTest2()
{
var rectangularArray = new string[, , ] {
{ { null, null }, { null, null }, { null, null } }, { { null, null }, { null, null }, { null, null } }
};
var outerProduct = new OuterProductIndexGenerator(rectangularArray);
var processor = new OuterProductProcessorOneLineString(rectangularArray);
outerProduct.ProcessOuterProduct(processor);
string s = processor.GetResult();
Assert.That(s, Is.EqualTo("{{(0,0,0),(0,0,1)},{(0,1,0),(0,1,1)},{(0,2,0),(0,2,1)}},{{(1,0,0),(1,0,1)},{(1,1,0),(1,1,1)},{(1,2,0),(1,2,1)}}"));
}
public void RectangularArrayTerminatingVisitorTest()
{
String[,] rectangularArray = new string[, ] {
{ "A1", "A2", "A3" }, { "B1", "B2", "B3" }, { "C1", "C2", "C3" }
};
var outerProduct = new OuterProductIndexGenerator(rectangularArray);
var processor = new OuterProductProcessorArrayPrinter(rectangularArray);
processor.NumberElementsToOutputInnermost = 2;
outerProduct.ProcessOuterProduct(processor);
string result = processor.GetResult();
Assert.That(result, Is.EqualTo("{A1,A2,...},{B1,B2,...},{C1,C2,...}"));
}
public void SamplePermutationVisitorTest()
{
var dimensionArray = new int[] { 2, 3, 2 };
var outerProduct = new OuterProductIndexGenerator(dimensionArray);
var processor = new OuterProductPermutations();
outerProduct.ProcessOuterProduct(processor);
var result = processor.outerProductPermutations;
var resultExpected = new int[][]
{
new int[] { 0, 0, 0 }, new int[] { 0, 0, 1 }, new int[] { 0, 1, 0 }, new int[] { 0, 1, 1 }, new int[] { 0, 2, 0 },
new int[] { 0, 2, 1 }, new int[] { 1, 0, 0 }, new int[] { 1, 0, 1 }, new int[] { 1, 1, 0 }, new int[] { 1, 1, 1 },
new int[] { 1, 2, 0 }, new int[] { 1, 2, 1 }
};
Assert.That(result.ToArray(), Is.EqualTo(resultExpected));
}
public void ProcessSameOuterProductMultipleTimesTest()
{
String[,] rectangularArray = new string[, ] {
{ "A1", "A2", "A3" }, { "B1", "B2", "B3" }, { "C1", "C2", "C3" }, { "D1", "D2", "D3" }
};
var outerProduct = new OuterProductIndexGenerator(rectangularArray);
OuterProductProcessorArrayPrinter processor = null;
int i = 0;
for (; i < 3; ++i)
{
processor = new OuterProductProcessorArrayPrinter(rectangularArray);
outerProduct.ProcessOuterProduct(processor);
}
Assert.That(i, Is.EqualTo(3));
string result = processor.GetResult();
Assert.That(result, Is.EqualTo("{A1,A2,A3},{B1,B2,B3},{C1,C2,C3},{D1,D2,D3}"));
}
public void VisitorNestedForOuterProductProcessorArrayPrettyPrinterTest()
{
var rectangularArray = new string[, , ] {
{ { "A0", "A1" }, { "B0", "B1" }, { "C0", "C1" } }, { { "D0", "D1" }, { "E0", "E1" }, { "F0", "F1" } }
};
var outerProduct = new OuterProductIndexGenerator(rectangularArray);
var processor = new OuterProductProcessorArrayPrettyPrinter(rectangularArray);
outerProduct.ProcessOuterProduct(processor);
string s = processor.GetResult();
const string resultExpected =
@"
{
{
A0
A1
}
{
B0
B1
}
{
C0
C1
}
}
{
{
D0
D1
}
{
E0
E1
}
{
F0
F1
}
}";
Assert.That(s, Is.EqualTo(resultExpected));
}
public void VisitorNestedForOuterProductProcessorPrettyPrinterTest()
{
var rectangularArray = new string[, , ] {
{ { null, null }, { null, null }, { null, null } }, { { null, null }, { null, null }, { null, null } }
};
var outerProduct = new OuterProductIndexGenerator(rectangularArray);
var processor = new OuterProductProcessorPrettyPrinter(rectangularArray);
outerProduct.ProcessOuterProduct(processor);
string s = processor.GetResult();
const string resultExpected =
@"
{
{
(0,0,0)
(0,0,1)
}
{
(0,1,0)
(0,1,1)
}
{
(0,2,0)
(0,2,1)
}
}
{
{
(1,0,0)
(1,0,1)
}
{
(1,1,0)
(1,1,1)
}
{
(1,2,0)
(1,2,1)
}
}";
Assert.That(s, Is.EqualTo(resultExpected));
}
