public void IncrementArray_NullOutput()
{
BitValue[] inputA = BitValueTest.GetInputs();
TestUtils.TestForError <ValidationFailedException>(
() =>
{
BitValue[] actual = null;
inputA.Increment(ref actual);
},
"Operation did not catch error.");
}
public void IncrementArray_DifferentSizeOutput()
{
BitValue[] inputA = BitValueTest.GetInputs();
TestUtils.TestForError <ValidationFailedException>(
() =>
{
var actual = new BitValue[3];
inputA.Increment(ref actual);
},
"Operation did not catch error.");
}
public void PullArray_NullOutput()
{
BitValue[] inputA = BitValueTest.GetInputs();
TestUtils.TestForError <ValidationFailedException>(
() =>
{
BitValue[] actual = null;
inputA.Pull(PullBehavior.PullUp, ref actual);
},
"Operation did not catch error.");
}
public void OrArray_NullOutput()
{
BitValue[] inputA = BitValueTest.GetInputs();
BitValue[] inputB = BitValueTest.GetInputs();
TestUtils.TestForError <ValidationFailedException>(
() =>
{
BitValue[] actual = null;
inputA.Or(inputB, ref actual, false);
},
"Operation did not catch error.");
}
public void AndArray_NullB()
{
BitValue[] inputA = BitValueTest.GetInputs();
BitValue[] inputB = null;
TestUtils.TestForError <ValidationFailedException>(
() =>
{
var actual = new BitValue[4];
inputA.And(inputB, ref actual, false);
},
"Operation did not catch error.");
}
public void XorArray_DifferentSizeOutput()
{
BitValue[] inputA = BitValueTest.GetInputs();
BitValue[] inputB = BitValueTest.GetInputs();
TestUtils.TestForError <ValidationFailedException>(
() =>
{
var actual = new BitValue[3];
inputA.Xor(inputB, ref actual, false);
},
"Operation did not catch error.");
}
public void InvertArray_SetA()
{
BitValue[] inputA = BitValueTest.GetInputs();
BitValue[] expected =
{
BitValue.One,
BitValue.Zero,
BitValue.Floating,
BitValue.Error
};
inputA.Invert(ref inputA);
BitValueTest.ValidateArraysEqual(inputA, expected);
}
public void PullArray_SetAPullDown()
{
BitValue[] inputA = BitValueTest.GetInputs();
BitValue[] expected =
{
BitValue.Zero,
BitValue.One,
BitValue.Zero,
BitValue.Error
};
inputA.Pull(PullBehavior.PullDown, ref inputA);
BitValueTest.ValidateArraysEqual(inputA, expected);
}
public void XorArray_SetA()
{
BitValue[] inputA = BitValueTest.GetInputs();
BitValue[] inputB = BitValueTest.GetInputs();
BitValue[] expected =
{
BitValue.Zero,
BitValue.Zero,
BitValue.Error,
BitValue.Error
};
inputA.Xor(inputB, ref inputA, false);
BitValueTest.ValidateArraysEqual(inputA, expected);
}
public void NegateArray_SetA()
{
BitValue[] inputA = BitValueTest.GetInputs();
BitValue[] expected =
{
BitValue.Error,
BitValue.Error,
BitValue.Error,
BitValue.Error
};
bool overflow = inputA.Negate(ref inputA);
BitValueTest.ValidateArraysEqual(inputA, expected);
Assert.Validate.IsFalse(overflow, "Operation should not have overflowed.");
}
public void NegateArray_NewArray()
{
BitValue[] inputA = BitValueTest.GetInputs();
BitValue[] expected =
{
BitValue.Error,
BitValue.Error,
BitValue.Error,
BitValue.Error
};
var actual = new BitValue[4];
bool overflow = inputA.Negate(ref actual);
BitValueTest.ValidateArraysEqual(actual, expected);
Assert.Validate.IsFalse(overflow, "Operation should not have overflowed.");
}
public void InvertArray_NewArray()
{
BitValue[] inputA = BitValueTest.GetInputs();
BitValue[] expected =
{
BitValue.One,
BitValue.Zero,
BitValue.Floating,
BitValue.Error
};
var actual = new BitValue[4];
inputA.Invert(ref actual);
BitValueTest.ValidateArraysEqual(actual, expected);
}
public void PUllArray_NewArrayUnchanged()
{
BitValue[] inputA = BitValueTest.GetInputs();
BitValue[] expected =
{
BitValue.Zero,
BitValue.One,
BitValue.Floating,
BitValue.Error
};
var actual = new BitValue[4];
inputA.Pull(PullBehavior.Unchanged, ref actual);
BitValueTest.ValidateArraysEqual(actual, expected);
}
public void XorArray_NewArray()
{
BitValue[] inputA = BitValueTest.GetInputs();
BitValue[] inputB = BitValueTest.GetInputs();
BitValue[] expected =
{
BitValue.Zero,
BitValue.Zero,
BitValue.Error,
BitValue.Error
};
var actual = new BitValue[4];
inputA.Xor(inputB, ref actual, false);
BitValueTest.ValidateArraysEqual(actual, expected);
}
public void And_IgnoreFloating()
{
BitValue[] inputA = BitValueTest.GetInputs();
BitValue[] inputB = BitValueTest.GetInputs();
BitValue[,] expected =
{
{
BitValue.Zero,
BitValue.Zero,
BitValue.Zero,
BitValue.Error
},
{
BitValue.Zero,
BitValue.One,
BitValue.One,
BitValue.Error
},
{
BitValue.Zero,
BitValue.One,
BitValue.Floating,
BitValue.Error
},
{
BitValue.Error,
BitValue.Error,
BitValue.Error,
BitValue.Error
}
};
for (var i = 0; i < inputA.Length; i++)
{
for (var j = 0; j < inputB.Length; j++)
{
BitValue actual = inputA[i].And(inputB[j], true);
Assert.Validate.AreEqual(
actual,
expected[i, j],
$"Operation failed at index {i},{j}.");
}
}
}
public void Invert()
{
BitValue[] input = BitValueTest.GetInputs();
BitValue[] expected =
{
BitValue.One,
BitValue.Zero,
BitValue.Floating,
BitValue.Error
};
for (var i = 0; i < input.Length; i++)
{
BitValue actual = input[i].Invert();
Assert.Validate.AreEqual(
actual,
expected[i],
$"Operation failed at index {i}.");
}
}
public void NegateArray_NegativeOne()
{
BitValue[] inputA =
{
BitValue.One,
BitValue.One,
BitValue.One,
BitValue.One
};
BitValue[] expected =
{
BitValue.One,
BitValue.Zero,
BitValue.Zero,
BitValue.Zero
};
var actual = new BitValue[4];
bool overflow = inputA.Negate(ref actual);
BitValueTest.ValidateArraysEqual(actual, expected);
Assert.Validate.IsFalse(overflow, "Operation should not have overflowed.");
}
public void IncrementArray_Fifteen()
{
BitValue[] inputA =
{
BitValue.One,
BitValue.One,
BitValue.One,
BitValue.One
};
BitValue[] expected =
{
BitValue.Zero,
BitValue.Zero,
BitValue.Zero,
BitValue.Zero
};
var actual = new BitValue[4];
bool overflow = inputA.Increment(ref actual);
BitValueTest.ValidateArraysEqual(actual, expected);
Assert.Validate.IsTrue(overflow, "Operation should have overflowed.");
}
