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 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 EqualFlagsTest()
{
Assert.NotEqual(FlagTest1.ToString(), FlagTest2.ToString());
Assert.NotEqual(FlagTest3.ToString(), FlagTest4.ToString());
Assert.NotEqual(FlagTest2.ToString(), FlagTest4.ToString());
Assert.Equal(FlagTest1.ToString(), FlagTest1_1.ToString());
}
public void lengthMaxPossibleTest()
{
ulong length = 17179868704;
MultipleBinaryFlag flag = new MultipleBinaryFlag(length);
BaseFileWorker.Write(flag.ToString(), "../../../test4.txt");
Assert.Equal(flag.ToString(),
BaseFileWorker.ReadAll("../../../test4.txt"));
}
public void lengthTest()
{
ulong length = 10;
MultipleBinaryFlag flag = new MultipleBinaryFlag(length);
BaseFileWorker.Write(flag.ToString(), "../../../test3.txt");
Assert.Equal(flag.ToString(),
BaseFileWorker.ReadAll("../../../test3.txt"));
}
public void setTest()
{
ulong length = 10;
MultipleBinaryFlag flag = new MultipleBinaryFlag(length, false);
flag.SetFlag(7);
flag.SetFlag(0);
BaseFileWorker.Write(flag.ToString(), "../../../test5.txt");
Assert.Equal(flag.ToString(), BaseFileWorker.ReadAll("../../../test5.txt"));
}
public void Test_Get_Flag_Equal_With_Added_Flag()
{
MultipleBinaryFlag mbf = new MultipleBinaryFlag(8);
string resView;
bool?resValue;
fdu.AddFlag(mbf.ToString(), true);
fdu.GetFlag(2, out resView, out resValue);
Assert.AreEqual(resView, mbf.ToString());
Assert.AreEqual(resValue, mbf.GetFlag());
}
public void TestDispose()
{
MultipleBinaryFlag flag = new MultipleBinaryFlag(test_length, false);
flag.SetFlag(3);
Assert.AreEqual(flag.ToString(), "FFFTFFFFFF");
flag.Dispose();
Assert.NotNull(flag);
Assert.AreNotEqual(flag.ToString(), "FFFTFFFFFF");
}
public void ToStringTest()
{
Assert.AreEqual("TTTTTTT", flag_1.ToString());
Assert.AreEqual("TTTTTTT", flag_2.ToString());
Assert.AreEqual("FFFFFFF", flag_3.ToString());
flag_1.ResetFlag(0);
flag_2.ResetFlag(3);
flag_3.SetFlag(0);
Assert.AreEqual("FTTTTTT", flag_1.ToString());
Assert.AreEqual("TTTFTTT", flag_2.ToString());
Assert.AreEqual("TFFFFFF", flag_3.ToString());
}
public void Test_GetFlag()
{
var flag = new MultipleBinaryFlag(5, false);
flag.SetFlag(3); flag.SetFlag(4);
_databaseConnection.AddFlag(flag.ToString(), (bool)flag.GetFlag());
int? id = _databaseConnection.GetIntBySql("SELECT TOP (1) [MultipleBinaryFlagID] FROM [IIG.CoSWE.FlagpoleDB].[dbo].[MultipleBinaryFlags] ORDER BY [MultipleBinaryFlagID] DESC");
string actualFlagView;
bool? actualFlagValue;
var result = _databaseConnection.GetFlag((int)id, out actualFlagView, out actualFlagValue);
Assert.IsTrue(result);
Assert.AreEqual(actualFlagView, flag.ToString());
Assert.AreEqual(actualFlagValue, flag.GetFlag());
}
public void shouldDisposeFlags_Dispose(ulong lenght, bool initValue)
{
var obj = new MultipleBinaryFlag(lenght, initValue);
obj.Dispose();
Assert.Null(obj.ToString());
}
public void lengthTest()
{
ulong length = 10;
MultipleBinaryFlag flag = new MultipleBinaryFlag(length);
Assert.Equal((int)length, flag.ToString().Length);
}
public void TestReadAllMultiple()
{
/*
* Input file contains
* 'TTTTTTTT'
* 'FFFFFFFF'
*/
ulong tmp = 8;
MultipleBinaryFlag testFlag1 = new MultipleBinaryFlag(tmp, true);
MultipleBinaryFlag testFlag2 = new MultipleBinaryFlag(tmp, false);
string testFlags1 = testFlag1.ToString() + "\r\n" + testFlag2.ToString();
string testFlags2 = testFlag2.ToString() + "\r\n" + testFlag1.ToString();
Assert.AreEqual(testFlags1, BaseFileWorker.ReadAll(inputFileMultiple));
Assert.AreNotEqual(testFlags2, BaseFileWorker.ReadAll(inputFileMultiple));
}
public void TestWriteToString2()
{
ulong tmp = 8;
MultipleBinaryFlag testFlag = new MultipleBinaryFlag(tmp, false);
Assert.IsTrue(BaseFileWorker.Write(testFlag.ToString(), outputFile));
}
public void GetFlagTest()
{
MultipleBinaryFlag FlagTest1 = new MultipleBinaryFlag(3, false);
FlagTest1.SetFlag(0);
FlagTest1.SetFlag(2);
connectionWithDB.GetFlag(7, out string flagView1, out bool?flagValue1);
Assert.AreEqual(flagView1, FlagTest1.ToString());
Assert.AreEqual(flagValue1, FlagTest1.GetFlag());
MultipleBinaryFlag FlagTest2 = new MultipleBinaryFlag(6, true);
connectionWithDB.GetFlag(3, out string flagView2, out bool?flagValue2);
Assert.AreEqual(flagView2, FlagTest2.ToString());
Assert.AreEqual(flagValue2, FlagTest2.GetFlag());
MultipleBinaryFlag FlagTest3 = new MultipleBinaryFlag(6, false);
connectionWithDB.GetFlag(3, out string flagView3, out bool?flagValue3);
Assert.AreNotEqual(flagView3, FlagTest3.ToString());
Assert.AreNotEqual(flagValue3, FlagTest3.GetFlag());
MultipleBinaryFlag FlagTest4 = new MultipleBinaryFlag(33, false);
FlagTest4.SetFlag(32);
connectionWithDB.GetFlag(5, out string flagView4, out bool?flagValue4);
Assert.AreNotEqual(flagView4, FlagTest4.ToString());
Assert.AreEqual(flagValue4, FlagTest4.GetFlag());
}
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 TestFlagLength()
{
ulong tmp = 42069;
MultipleBinaryFlag test1 = new MultipleBinaryFlag(tmp, true);
Assert.Equals(tmp, test1.ToString().Length);
}
public void Test_Add_MinFlag_InitialValueFalse()
{
var flag = new MultipleBinaryFlag(2, false);
var result = _databaseConnection.AddFlag(flag.ToString(), (bool)flag.GetFlag());
Assert.IsTrue(result);
}
public void reset0Test()
{
ulong length = 10;
MultipleBinaryFlag flag = new MultipleBinaryFlag(length);
flag.ResetFlag(0);
Assert.Equal("FTTTTTTTTT", flag.ToString());
}
public void TestReadLinesMultiple()
{
/*
* Input file contains
* 'TTTTTTTT'
* 'FFFFFFFF'
*/
ulong tmp = 8;
MultipleBinaryFlag testFlag1 = new MultipleBinaryFlag(tmp, true);
MultipleBinaryFlag testFlag2 = new MultipleBinaryFlag(tmp, false);
string[] input = BaseFileWorker.ReadLines(inputFileMultiple);
Assert.AreEqual(testFlag1.ToString(), input[0]);
Assert.AreEqual(testFlag2.ToString(), input[1]);
Assert.AreNotEqual(testFlag2.ToString(), input[0]);
Assert.AreNotEqual(testFlag1.ToString(), input[1]);
}
public void set0Test()
{
ulong length = 10;
MultipleBinaryFlag flag = new MultipleBinaryFlag(length, false);
flag.SetFlag(0);
Assert.Equal("TFFFFFFFFF", flag.ToString());
}
public void shouldReturnIfFlagObjIsNull_SetFlag(ulong lenght, bool initValue, ulong position)
{
var obj = new MultipleBinaryFlag(lenght, initValue);
obj.Dispose();
obj.SetFlag(position);
Assert.Null(obj.ToString());
}
public void TestAddFlagFalse(ulong length)
{
MultipleBinaryFlag mbf = new MultipleBinaryFlag(length, false);
bool actual = mbf.GetFlag();
Assert.True(flagDatabaseUtils.AddFlag(mbf.ToString(), actual));
flagDatabaseUtils.ExecSql("DELETE FROM dbo.MultipleBinaryFlags");
}
public void Dispose()
{
var flag = new MultipleBinaryFlag(9);
flag.Dispose();
Assert.Null(flag.ToString());
}
public void ToStringWithResetFlagTest()
{
MultipleBinaryFlag tmp = new MultipleBinaryFlag(10);
tmp.ResetFlag(4);
tmp.ResetFlag(7);
Assert.Equal("TTTTFTTFTT", tmp.ToString());
}
public void TestAddFlagFalse()
{
MultipleBinaryFlag bFlag = new MultipleBinaryFlag(10, false);
string flagView = bFlag.ToString();
bool flagValue = bFlag.GetFlag();
Assert.True(flagpoleDB.AddFlag(flagView, flagValue));
}
public void disposeSmallTest()
{
ulong length = 10;
MultipleBinaryFlag flag = new MultipleBinaryFlag(length);
flag.Dispose();
Assert.NotEqual("TTTTTTTTTT", flag.ToString());
}
public void AddFlag_GetFlag(ulong num, Boolean val)
{
databaseFixture.index++;
var binaryFlag = new MultipleBinaryFlag(num, val);
var flagView = binaryFlag.ToString();
var flag = binaryFlag.GetFlag();
var boolean = binaryFlag.GetFlag() ?? false;
Boolean res = databaseFixture.database.AddFlag(binaryFlag.ToString(), boolean);
Assert.True(res);
Boolean res2 = databaseFixture.database.GetFlag(databaseFixture.index, out flagView, out flag);
Assert.True(res2);
Assert.Equal(flagView, binaryFlag.ToString());
Assert.Equal(flag, binaryFlag.GetFlag());
}
public void SetFlagRangeTest(ulong length, string expected)
{
var binaryFlag = new MultipleBinaryFlag(length, false);
binaryFlag.SetFlag(0);
binaryFlag.SetFlag(2);
Assert.Equal(binaryFlag.ToString(), expected);
}
