public void ResetFlagRangeException()
{
Assert.ThrowsAny <ArgumentOutOfRangeException>(() => FlagTest1.ResetFlag(6));
Assert.ThrowsAny <ArgumentOutOfRangeException>(() => FlagTest2.ResetFlag(9));
Assert.ThrowsAny <ArgumentOutOfRangeException>(() => FlagTest3.ResetFlag(35));
Assert.ThrowsAny <ArgumentOutOfRangeException>(() => FlagTest4.ResetFlag(67));
}
private void ResetAllClass()
{
for (ulong i = 0; i < SIZE; i++)
{
_MBF.ResetFlag(i);
}
}
public void AddFlagTest()
{
MultipleBinaryFlag FlagTest = new MultipleBinaryFlag(6, true);
Assert.IsTrue(connectionWithDB.AddFlag(FlagTest.ToString(), FlagTest.GetFlag()));
FlagTest.ResetFlag(1);
FlagTest.ResetFlag(2);
Assert.IsTrue(connectionWithDB.AddFlag(FlagTest.ToString(), FlagTest.GetFlag()));
MultipleBinaryFlag FlagTest1 = new MultipleBinaryFlag(33, false);
Assert.IsTrue(connectionWithDB.AddFlag(FlagTest1.ToString(), FlagTest.GetFlag()));
MultipleBinaryFlag FlagTest2 = new MultipleBinaryFlag(66, false);
Assert.IsTrue(connectionWithDB.AddFlag(FlagTest2.ToString(), FlagTest.GetFlag()));
//AddFlag manually
Assert.IsTrue(connectionWithDB.AddFlag("TFT", false));
Assert.IsTrue(connectionWithDB.AddFlag("TT", true));
Assert.IsTrue(connectionWithDB.AddFlag("FFFTTFT", false));
//AddFlag manually with errors
Assert.IsFalse(connectionWithDB.AddFlag("FF", true));
Assert.IsFalse(connectionWithDB.AddFlag("TT", false));
}
public void ResetFlag_ToFail_WithBiggerIndexThanLength()
{
var flag = new MultipleBinaryFlag(10);
Assert.Throws <ArgumentOutOfRangeException>(() => flag.ResetFlag(12));
Assert.Throws <ArgumentOutOfRangeException>(() => flag.ResetFlag(10));
}
public void TestToString()
{
MultipleBinaryFlag mbf = new MultipleBinaryFlag(4, false);
MultipleBinaryFlag mbt = new MultipleBinaryFlag(4, true);
Assert.AreEqual(mbt.ToString(), "TTTT");
Assert.AreEqual(mbf.ToString(), "FFFF");
//test to string after flag setting
mbf.SetFlag(1);
Assert.AreEqual(mbf.ToString(), "FTFF");
for (ulong i = 0; i < 4; i++)
{
mbf.SetFlag(i);
}
Assert.AreEqual(mbf.ToString(), "TTTT");
//test to string after flag resettting
mbf.ResetFlag(1);
Assert.AreEqual(mbf.ToString(), "TFTT");
for (ulong i = 0; i < 4; i++)
{
mbf.ResetFlag(i);
}
Assert.AreEqual(mbf.ToString(), "FFFF");
}
/// <summary>
/// Runs full test of MultipleBinaryFlag given specified length and initialValue.
/// Consists of such steps:
/// 1. Test that new object is setting up initial value correctly by checking GetFlag() and ToString() method's return values.
/// 2. Test ResetFlag() works as intended by resetting flag at each position of 0..length-1. Checks expected output of GetFlag() and ToString() on each step.
/// 3. Test SetFlag() similar to p.2 (ResetFlag())
/// 4. Test ArgumentOutOfRangeException is being thrown when calling ResetFlag() or SetFlag() with position>=length
/// </summary>
/// <param name="len"></param>
/// <param name="initialValue"></param>
private static void TestFullFlow(ulong length, bool initialValue)
{
MultipleBinaryFlag impl = new MultipleBinaryFlag(length, initialValue);
// 1. Test that new object is setting up initial value correctly.
char expected_char = initialValue ? 'T' : 'F';
string expected = new string(expected_char, (int)length);
char[] expected_arr = expected.ToCharArray();
Assert.AreEqual(initialValue, impl.GetFlag()); // GetFlag should be equal to initialValue right after object construction
var actual = impl.ToString();
Assert.AreEqual <string>(expected, actual, $"Expected string of '{expected_char}' chars of {length} symbols. Got '{actual}' instead");
// 2. Test ResetFlag(): apply reset for each element by one, compare output (ToString) to expected.
// Also checks if GetFlag() returns false (since not all elements are True)
for (ulong i = 0; i < length; ++i)
{
impl.ResetFlag(i);
expected_arr[i] = 'F';
expected = new string(expected_arr);
actual = impl.ToString();
Assert.AreEqual <string>(expected, actual);
Assert.IsFalse(impl.GetFlag());
}
// 3. Test SetFlag(): set flag for each position by one, compare output (ToString) to expected.
// Also checks if GetFlag() returns false (since not all elements are True)
for (ulong i = 0; i < length; ++i)
{
impl.SetFlag(i);
expected_arr[i] = 'T';
expected = new string(expected_arr);
actual = impl.ToString();
Assert.AreEqual <string>(expected, actual);
// After last step (i==len-1) flag should become true.
// Before that it should remain false, as not all flags are true.
if (i < length - 1)
{
Assert.IsFalse(impl.GetFlag());
}
else
{
Assert.IsTrue(impl.GetFlag());
}
}
// 4. Test ArgumentOutOfRangeException is being thrown when calling ResetFlag/SetFlag with position>=length
Action throws_outOfRange_resetFlag = () => { impl.ResetFlag(length); };
Action throws_outOfRange_setFlag = () => { impl.SetFlag(length); };
Assert.ThrowsException <ArgumentOutOfRangeException>(throws_outOfRange_setFlag);
Assert.ThrowsException <ArgumentOutOfRangeException>(throws_outOfRange_resetFlag);
impl.Dispose();
}
public void Test_resetting_all_positions()
{
MultipleBinaryFlag testBinaryFlag = new MultipleBinaryFlag(2);
testBinaryFlag.ResetFlag(0);
testBinaryFlag.ResetFlag(1);
Assert.False(testBinaryFlag.GetFlag());
}
public void ToStringWithResetFlagTest()
{
MultipleBinaryFlag tmp = new MultipleBinaryFlag(10);
tmp.ResetFlag(4);
tmp.ResetFlag(7);
Assert.Equal("TTTTFTTFTT", tmp.ToString());
}
public void ResetFlagTest()
{
FlagTest1.ResetFlag(1);
FlagTest1.ResetFlag(2);
Assert.False(FlagTest1.GetFlag());
FlagTest2.ResetFlag(2);
Assert.False(FlagTest2.GetFlag());
}
public void Test_after_double_resetting()
{
MultipleBinaryFlag testBinaryFlag = new MultipleBinaryFlag(2);
uint pos = 1;
testBinaryFlag.ResetFlag(pos);
testBinaryFlag.ResetFlag(pos);
testBinaryFlag.SetFlag(pos);
Assert.True(testBinaryFlag.GetFlag());
}
public void resetTest()
{
ulong length = 10;
MultipleBinaryFlag flag = new MultipleBinaryFlag(length);
flag.ResetFlag(7);
flag.ResetFlag(0);
BaseFileWorker.Write(flag.ToString(), "../../../test6.txt");
Assert.Equal(flag.ToString(), BaseFileWorker.ReadAll("../../../test6.txt"));
}
public void ResetFlag_AfterDispose()
{
var flag = new MultipleBinaryFlag(9);
flag.Dispose();
flag.ResetFlag(4);
flag.ResetFlag(2);
Assert.Null(flag.ToString());
}
public void GetAllFromOtherManualFile()
{
MultipleBinaryFlag first = new MultipleBinaryFlag(5, true);
MultipleBinaryFlag second = new MultipleBinaryFlag(4, true);
first.ResetFlag(2);
first.ResetFlag(3);
string[] lines = BaseFileWorker.ReadAll(path + "manualWritedFile.txt").Split("\r\n");
Assert.AreEqual(lines[0], first.ToString() + " " + first.GetFlag());
Assert.AreEqual(lines[1], second.ToString() + " " + second.GetFlag());
}
public void ResetFlag_WithCorrectIndex()
{
var flag = new MultipleBinaryFlag(10);
flag.ResetFlag(0);
flag.ResetFlag(8);
flag.ResetFlag(9);
var expected = "F" + string.Concat(Enumerable.Repeat("T", 7)) + "FF";
Assert.Equal(expected, flag.ToString());
}
public void TestMultipleReset()
{
ulong tmp = 2;
ulong position1 = 0;
ulong position2 = 1;
MultipleBinaryFlag test1 = new MultipleBinaryFlag(tmp, true);
test1.ResetFlag(position1);
test1.ResetFlag(position2);
Assert.IsTrue(test1.GetFlag());
Assert.AreEqual(test1.ToString(), "TT");
}
public void WriteFileToDisk()
{
MultipleBinaryFlag first = new MultipleBinaryFlag(7, true);
MultipleBinaryFlag second = new MultipleBinaryFlag(10, false);
first.ResetFlag(0);
first.ResetFlag(2);
first.ResetFlag(5);
second.SetFlag(1);
second.SetFlag(3);
second.SetFlag(7);
second.SetFlag(9);
Assert.IsTrue(BaseFileWorker.Write(first.ToString() + " " + first.GetFlag() + "\r\n" + second.ToString() + " " + second.GetFlag(), path + "writedFileWithFlag.txt"));
}
public void ResetFlagTest()
{
MultipleBinaryFlag flag = new MultipleBinaryFlag(3, false);
flag.SetFlag(0);
flag.SetFlag(1);
flag.SetFlag(2);
Assert.True(flag.GetFlag());
flag.ResetFlag(0);
Assert.False(flag.GetFlag());
flag.ResetFlag(1);
flag.ResetFlag(2);
Assert.False(flag.GetFlag());
}
public void Test_GetFlag_Changed_Twice_True()
{
MultipleBinaryFlag multipleBinaryFlag = new MultipleBinaryFlag(3);
multipleBinaryFlag.ResetFlag(0);
multipleBinaryFlag.ResetFlag(0);
multipleBinaryFlag.SetFlag(0);
var result = multipleBinaryFlag.GetFlag();
BaseFileWorker.Write(result.ToString(), path);
string fromFile = BaseFileWorker.ReadAll(path);
Assert.Equal(Boolean.TrueString, fromFile);
Assert.True(result);
}
public void Test_Route_1_3_7_8_9_11()
{
var flag = new MultipleBinaryFlag(16);
flag.ResetFlag(10);
Assert.IsFalse(flag.GetFlag().Value);
}
public void Test_Route_1_3_7_2()
{
Assert.ThrowsException <ArgumentOutOfRangeException>(delegate() {
var flag = new MultipleBinaryFlag(20);
flag.ResetFlag(25);
});
}
public void testGetFlagWithSet(ulong length, bool initValue)
{
var mbf = new MultipleBinaryFlag(length, initValue);
var rand = new Random();
for (int i = 0, j = 0; i < (int)length && j < (int)length; i = rand.Next(i + 1, (int)length + 1), j = rand.Next(j + 1, (int)length + 1))
{
mbf.SetFlag((ulong)i);
mbf.ResetFlag((ulong)i);
}
string flagView = mbf.ToString();
bool flagValue = mbf.GetFlag();
string flagViewAfterDB = "";
bool? flagValueAfterDB = false;
flagpoleDatabase.AddFlag(flagView, flagValue);
bool isAdded = flagpoleDatabase.GetFlag(1, out flagViewAfterDB, out flagValueAfterDB);
Assert.True(isAdded);
Assert.Equal(flagView, flagViewAfterDB);
Assert.Equal(flagValue, flagValueAfterDB);
flagpoleDatabase.ExecSql("delete from MultipleBinaryFlags; DBCC CHECKIDENT (MultipleBinaryFlags, RESEED, 0);");
}
public void ExecutionRoute_0_1_3_6_8_11_InitialValueFalse_Exception()
{
var flag = new MultipleBinaryFlag(3, false);
flag.SetFlag(2);
flag.ResetFlag(4);
}
public void resetOutOfRangeTest()
{
ulong length = 10;
MultipleBinaryFlag flag = new MultipleBinaryFlag(length);
Assert.Throws <ArgumentOutOfRangeException>(() => flag.ResetFlag(100));
}
public void GetWrongLinesFromOtherFile()
{
MultipleBinaryFlag first = new MultipleBinaryFlag(7, true);
MultipleBinaryFlag second = new MultipleBinaryFlag(10, false);
first.ResetFlag(0);
first.ResetFlag(2);
first.ResetFlag(5);
second.SetFlag(1);
second.SetFlag(3);
second.SetFlag(7);
second.SetFlag(9);
string[] lines = BaseFileWorker.ReadLines(path + "manualWritedFile.txt");
Assert.AreNotEqual(lines[0], first.ToString() + " " + first.GetFlag());
Assert.AreNotEqual(lines[1], second.ToString() + " " + second.GetFlag());
}
public void Reset_WithCorrectIndex()
{
MultipleBinaryFlag flag = new MultipleBinaryFlag(2, true);
flag.ResetFlag(0);
Assert.False(flag.GetFlag());
}
public void GetAllFromFile()
{
MultipleBinaryFlag first = new MultipleBinaryFlag(7, true);
MultipleBinaryFlag second = new MultipleBinaryFlag(10, false);
first.ResetFlag(0);
first.ResetFlag(2);
first.ResetFlag(5);
second.SetFlag(1);
second.SetFlag(3);
second.SetFlag(7);
second.SetFlag(9);
string[] lines = BaseFileWorker.ReadAll(path + "writedFileWithFlag.txt").Split("\r\n");
Assert.AreEqual(lines[0], first.ToString() + " " + first.GetFlag());
Assert.AreEqual(lines[1], second.ToString() + " " + second.GetFlag());
}
public void MBF_SetFlag_ResetFlag_Exception(ulong l, bool v, ulong pos)
{
var mbf = new MultipleBinaryFlag(l, v);
Assert.Throws <ArgumentOutOfRangeException>(() => mbf.SetFlag(pos));
Assert.Throws <ArgumentOutOfRangeException>(() => mbf.ResetFlag(pos));
}
public void TestReadlAllNotEqualGetFlag()
{
MultipleBinaryFlag flag = new MultipleBinaryFlag(2);
flag.ResetFlag(1);
Assert.AreNotEqual(flag.GetFlag().ToString(), BaseFileWorker.ReadAll(readAllFile));
}
private static void ResetUnevenFlags(MultipleBinaryFlag f, ulong length)
{
for (ulong i = 1; i < length; i += 2)
{
f.ResetFlag(i);
}
}
public void shouldReturnFalseifResetFlagWasCalled_GetFlag(ulong lenght, bool initValue)
{
var obj = new MultipleBinaryFlag(lenght, initValue);
obj.ResetFlag(1);
Assert.False(obj.GetFlag());
}
