public void GetSwitches_Test() {
Vertex
v1 = new Vertex(48, 50, 2, 4),
v2 = new Vertex(49, 48, 2, 4),
v3 = new Vertex(54, 53, 2, 4),
v4 = new Vertex(50, 51, 3, 4),
v5 = new Vertex(50, 49, 2, 4),
v6 = new Vertex(65, 66, 2, 4),
v7 = new Vertex(97, 98, 3, 4),
v8 = new Vertex(96, 35, 2, 4),
v9 = new Vertex(95, 26, 2, 4);
Edge
e1 = new Edge(v2, v3, 5, true, true),
e2 = new Edge(v2, v5, 1, true, true),
e3 = new Edge(v2, v6, 17, true, false),
e4 = new Edge(v2, v3, 5, false, false),
e5 = new Edge(v2, v5, 1, false, false),
e7 = new Edge(v8, v9, 1, true, true),
e6 = new Edge(v2, v6, 17, false, true),
e8 = new Edge(v8, v9, 9, false, false);
Graph g = new Graph() {
Vertices = {v1, v2, v3, v4, v5, v6, v7, v8, v9},
Edges = {e1, e2, e3, e4, e5, e6, e7, e8}
};
Assert.AreEqual(new List<Edge> {e5,e7}.ToString(), g.GetSwitches().ToString() );
}
public void Vertex_ToStringTest()
{
short SampleInput1 = 5;
short SampleInput2 = 6;
byte messageInput = 11;
byte modulo = 4;
Vertex vertex1 = new Vertex(SampleInput1, SampleInput2, messageInput, modulo);
Assert.AreEqual("(5,6)", vertex1.ToString());
}
public void GraphToString_Test()
{
short SampleInput1 = 5;
short SampleInput2 = 6;
byte messageInput1 = 11;
byte modulo1 = 100;
Vertex vertex1 = new Vertex(SampleInput1, SampleInput2, messageInput1, modulo1);
short SampleInput3 = 7;
short SampleInput4 = 8;
byte messageInput2 = 100;
byte modulo2 = 100;
Vertex vertex2 = new Vertex(SampleInput3, SampleInput4, messageInput2, modulo2);
Graph graph1 = new Graph();
graph1.Vertices.Add(vertex1);
graph1.Vertices.Add(vertex2);
Assert.AreEqual("These are my vertices: \n(5,6)\n(7,8)\n", graph1.ToString());
}
public void MergeGraphAndQuantizedValues_Test()
{
JpegImage ji = new JpegImage(new Bitmap(200, 100), 100, 4);
PrivateObject po = new PrivateObject(ji);
Vertex
v1 = new Vertex(2, 3, 1, 4);
Graph inputGraph = new Graph();
inputGraph.Vertices.Add(v1);
short[,] inBlock8 = new short[8, 8];
var expectedTuple = new Tuple<short[,], HuffmanTable, HuffmanTable, int>(inBlock8, ji.YDCHuffman, ji.YACHuffman, 0);
var quantizedBlocks = new List<Tuple<short[,], HuffmanTable, HuffmanTable, int>>();
var expectedQuantizedBlocks = new List<Tuple<short[,], HuffmanTable, HuffmanTable, int>>();
quantizedBlocks.Add(expectedTuple);
expectedQuantizedBlocks = quantizedBlocks;
po.Invoke("_mergeGraphAndQuantizedValues", inputGraph);
var returnedQuantizedBlocks = (List<Tuple<short[,], HuffmanTable, HuffmanTable, int>>)po.GetField("_quantizedBlocks");
Assert.AreEqual(expectedQuantizedBlocks.ToString(), returnedQuantizedBlocks.ToString());
}
public void ForceSampleChange()
{
PrivateType pt = new PrivateType(typeof(JpegImage));
Vertex
inputVertex = new Vertex(0, 1, 0, 4),
expectedVertex = new Vertex(-1, 1, 0, 4);
pt.InvokeStatic("_forceSampleChange", inputVertex);
Assert.AreEqual(expectedVertex.ToString(), inputVertex.ToString());
}
public void SwapVertexData()
{
PrivateType pt = new PrivateType(typeof(JpegImage));
Vertex
inputV1 = new Vertex(0, 1, 0, 4),
inputV2 = new Vertex(2, 3, 0, 4),
expectedV1 = new Vertex(2, 1, 0, 4),
expectedV2 = new Vertex(0, 3, 0, 4);
Edge
inputE1 = new Edge(inputV1, inputV2, 0, true, true),
expectedE1 = new Edge(expectedV1, expectedV2, 0, true, true);
pt.InvokeStatic("_swapVertexData", inputE1);
Assert.AreEqual(expectedE1.ToString(), inputE1.ToString());
}
public void RefactorGraph_Test() //TODO: fix this test
{
PrivateType pt = new PrivateType(typeof(JpegImage));
Vertex
v1 = new Vertex(0, 1, 0, 4),
v2 = new Vertex(2, 3, 2, 4),
v3 = new Vertex(4, 5, 3, 4),
v4 = new Vertex(6, 7, 3, 4),
v5 = new Vertex(8, 9, 4, 4),
v6 = new Vertex(10, 11, 5, 4);
Edge
e1 = new Edge(v1, v2, 1, true, false),
e2 = new Edge(v3, v4, 2, true, true),
e3 = new Edge(v5, v6, 2, false, true);
Graph inputGraph = new Graph();
Graph sad = new Graph();
inputGraph.Edges.Add(e1);
inputGraph.Edges.Add(e2);
inputGraph.Edges.Add(e3);
sad.Edges.Add(e1);
sad.Edges.Add(e2);
sad.Edges.Add(e3);
sad.Vertices.AddRange(new List<Vertex>() { v1, v2, v3, v4, v5, v6 });
inputGraph.Vertices.AddRange(new List<Vertex>() { v1, v2, v3, v4, v5, v6 });
pt.InvokeStatic("_refactorGraph", inputGraph);
Assert.AreEqual(sad.Vertices, inputGraph.Vertices);
}
public void AddEdge_Test()
{
PrivateType pt = new PrivateType(typeof(JpegImage));
Vertex
v1 = new Vertex(0, 1, 0, 4),
v2 = new Vertex(2, 3, 2, 4),
v3 = new Vertex(4, 5, 3, 4),
v4 = new Vertex(6, 7, 3, 4),
v5 = new Vertex(8, 9, 4, 4),
v6 = new Vertex(10, 11, 5, 4);
Graph inputGraph = new Graph();
inputGraph.Vertices.AddRange(new List<Vertex>() { v1, v2, v3, v4, v5, v6 });
int inputThreshold = 5;
pt.InvokeStatic("_addEdge", new object[] {true, false, v1, v2, inputThreshold, inputGraph}); //pass
pt.InvokeStatic("_addEdge", new object[] {true, true, v3, v4, inputThreshold, inputGraph}); //pass
pt.InvokeStatic("_addEdge", new object[] {false, true, v5, v6, inputThreshold, inputGraph}); //fail
Graph expectedGraph = new Graph();
expectedGraph.Edges.Add(new Edge(v1, v2, 3, true, false));
expectedGraph.Edges.Add(new Edge(v3, v4, 2, true, true));
Assert.AreEqual(expectedGraph.Edges, inputGraph.Edges);
}
public void AddVertices_Test()
{
PrivateObject po = new PrivateObject(new JpegImage(new Bitmap(200, 100), 100, 4));
List<short> inputNonZeroValues = new List<short>();
List<byte> inputMessage = new List<byte>();
for (int i = 0; i < 20; i++)
{
inputNonZeroValues.Add((short)i);
}
for (int e = 0; e < 10; e++)
{
inputMessage.Add((byte)e);
}
po.SetField("_nonZeroValues", inputNonZeroValues);
po.SetField("_message",inputMessage);
Vertex
v1 = new Vertex(0, 1, 0, 4),
v2 = new Vertex(2, 3, 1, 4),
v3 = new Vertex(4, 5, 2, 4),
v4 = new Vertex(6, 7, 3, 4),
v5 = new Vertex(8, 9, 4, 4),
v6 = new Vertex(10, 11, 5, 4),
v7 = new Vertex(12, 13, 6, 4),
v8 = new Vertex(14, 15, 7, 4),
v9 = new Vertex(16, 17, 8, 4),
v10 = new Vertex(18, 19, 9, 4);
Graph returnedGraph = new Graph();
Graph expectedGraph = new Graph();
expectedGraph.Vertices.AddRange(new List<Vertex>() {v1, v2, v3, v4, v5, v6, v7, v8, v9, v10});
po.Invoke("_addVertices", returnedGraph);
Assert.AreEqual(expectedGraph.ToString(), returnedGraph.ToString());
}
private static void _forceSampleChange(Vertex vertex) {
int error = (vertex.SampleValue1 + vertex.SampleValue2).Mod(vertex.Modulo) - vertex.Message;
if (vertex.SampleValue1 - error <= 127 && vertex.SampleValue1 - error >= -128 &&
vertex.SampleValue1 - error != 0) {
vertex.SampleValue1 -= error;
} else if (vertex.SampleValue2 - error <= 127 && vertex.SampleValue2 - error >= -128 &&
vertex.SampleValue2 - error != 0) {
vertex.SampleValue2 -= error;
} else {
vertex.SampleValue1 += vertex.Modulo - error;
}
}
private static void _addEdge(bool firstFirst, bool secondFirst, Vertex first, Vertex second, int threshold, Graph g) {
if (((firstFirst ? first.SampleValue2 : first.SampleValue1) + (secondFirst ? second.SampleValue1 : second.SampleValue2)).Mod(first.Modulo) == first.Message) {
if (((firstFirst ? first.SampleValue1 : first.SampleValue2) + (secondFirst ? second.SampleValue2 : second.SampleValue1)).Mod(second.Modulo) == second.Message) {
Edge e = new Edge(first, second, firstFirst, secondFirst);
if (e.Weight < threshold) {
g.Edges.Add(e);
}
}
}
}
public Edge(Vertex vStart, Vertex vEnd, bool vStartFirstItem, bool vEndFirstItem) {
VStart = vStart;
VEnd = vEnd;
VStartFirst = vStartFirstItem;
VEndFirst = vEndFirstItem;
}
private static void _addEdge(bool startFirst, bool endFirst, Vertex first, Vertex second, int threshold, Graph g) {
short weight = (short)Math.Abs((startFirst ? first.SampleValue1 : first.SampleValue2) - (endFirst ? second.SampleValue1 : second.SampleValue2));
if (weight < threshold) {
if (((startFirst ? first.SampleValue2 : first.SampleValue1) + (endFirst ? second.SampleValue1 : second.SampleValue2)).Mod(first.Modulo) == first.Message) {
if (((startFirst ? first.SampleValue1 : first.SampleValue2) + (endFirst ? second.SampleValue2 : second.SampleValue1)).Mod(second.Modulo) == second.Message) {
lock (g) {
g.Edges.Add(new Edge(first, second, weight, startFirst, endFirst));
}
}
}
}
}
