public static string GetValueByKey(string key, string testDataType, bool ignoreCase = true)
{
if (key == testDataType)
{
return(key);
}
TestDataType type = Utility.ParseEnum <TestDataType>(testDataType);
if (type == TestDataType.Share)
{
return(SharedData.Where(f => f.Key.EqualsText(key, ignoreCase)).Select(f => f.Value).FirstOrDefault());
}
else if (type == TestDataType.TestPlan)
{
return(TestPlanData.Where(f => f.Key.EqualsText(key, ignoreCase)).Select(f => f.Value).FirstOrDefault());
}
else if (type == TestDataType.TestSuite)
{
return(TestSuitData.DataList.Where(f => f.Key.EqualsText(key, ignoreCase)).Select(f => f.Value).FirstOrDefault());
}
else if (type == TestDataType.TestCase)
{
return(CurrentTestCaseData.DataList.Where(f => f.Key.EqualsText(key, ignoreCase)).Select(f => f.Value).FirstOrDefault());
}
return(key);
}
public void Replace_ReplacedAndEventRaised()
{
TestDataManager dm = new TestDataManager();
TestDataType data1 = new TestDataType {
Id = 1U
}, data2 = new TestDataType {
Id = 2U
};
dm.Add(data1);
TestDataObserver obs = new TestDataObserver();
using IDisposable unsubscriber = dm.Subscribe(obs);
Assert.AreEqual(dm.Get(1U), data1);
dm.ReplaceData(new HashSet <TestDataType> {
data2
});
Assert.AreEqual(dm.Get(2U), data2);
Assert.AreEqual(0, obs.CompleteCount);
Assert.AreEqual(0, obs.Errors.Count);
Assert.AreEqual(1, obs.Next.Count);
DataChanged <TestDataType> change = obs.Next.Dequeue();
Assert.IsTrue(change.Action == DataChangedAction.Replace &&
change.OldItems?.FirstOrDefault() == data1 &&
change.NewItems?.FirstOrDefault() == data2);
}
public async Task Write_NegativeAbsoluteOffset_InvalidOperationExceptionThrown()
{
var fs = new MockFileSystem();
var file = fs.File.OpenWrite("test.dat");
// -4 + 0 == negative absolute offset
var data = new TestDataType(-4);
await Assert.ThrowsAsync <InvalidOperationException>(() => data.WriteAsync(file, 0, new NefsProgress()));
}
public static string GetFileName(TestDataType type, DataDirection direction)
{
var filename = $@"{type.ToString().ToLower()}_{direction.ToString().ToLower()}";
var path = Path.Combine(TestContext.CurrentContext.TestDirectory, "TestData", $@"{filename}.zip");
var tmpDir = GetTemporaryDirectory();
ZipFile.ExtractToDirectory(path, tmpDir);
return(Path.Combine(tmpDir, $@"{filename}.csv"));
}
internal static IEnumerable <TestBuilderContext> GetTestDataByDataType(TestDataType testDataType)
{
switch (testDataType)
{
case TestDataType.ValidData:
return(GetValidData());
}
return(default);
public void Add_AddedOnceAndEventRaised()
{
TestDataManager dm = new TestDataManager();
TestDataType data = new TestDataType();
TestDataObserver obs = new TestDataObserver();
using IDisposable unsubscriber = dm.Subscribe(obs);
dm.Add(data);
Assert.ThrowsException <ArgumentException>(() => dm.Add(data));
Assert.AreEqual(0, obs.CompleteCount);
Assert.AreEqual(0, obs.Errors.Count);
Assert.AreEqual(1, obs.Next.Count);
DataChanged <TestDataType> change = obs.Next.Dequeue();
Assert.IsTrue(change.Action == DataChangedAction.Add && change.NewItems?.FirstOrDefault() == data);
}
public async Task Read_NegativeAbsoluteOffset_InvalidOperationExceptionThrown()
{
var fs = new MockFileSystem();
fs.AddFile("test.dat", new MockFileData(new byte[] { 0x1, 0x2, 0x3, 0x4, 0x5 }));
// -4 + 0 == negative absolute offset
var data = new TestDataType(-4);
await Assert.ThrowsAsync <InvalidOperationException>(async() =>
{
using (var file = fs.File.OpenRead("test.dat"))
{
await data.ReadAsync(file, 0, new NefsProgress());
}
});
}
public async Task Read_PastEndOfFile_InvalidOperationExceptionThrown()
{
var fs = new MockFileSystem();
fs.AddFile("test.dat", new MockFileData(new byte[] { 0x1, 0x2, 0x3, 0x4, 0x5 }));
// 0 + 10 == past end of file
var data = new TestDataType(0);
await Assert.ThrowsAsync <InvalidOperationException>(async() =>
{
using (var file = fs.File.OpenRead("test.dat"))
{
await data.ReadAsync(file, 10, new NefsProgress());
}
});
}
public void Reset_ResetAndEventRaised()
{
TestDataManager dm = new TestDataManager();
TestDataType data = new TestDataType();
dm.Add(data);
TestDataObserver obs = new TestDataObserver();
using IDisposable unsubscriber = dm.Subscribe(obs);
dm.Reset();
Assert.IsFalse(dm.GetAll().Any());
Assert.AreEqual(0, obs.CompleteCount);
Assert.AreEqual(0, obs.Errors.Count);
Assert.AreEqual(1, obs.Next.Count);
DataChanged <TestDataType> change = obs.Next.Dequeue();
Assert.IsTrue(change.Action == DataChangedAction.Reset && change.OldItems?.FirstOrDefault() == data);
}
public async Task Read_PositiveDataOffset_ReadSuccess()
{
var fs = new MockFileSystem();
fs.AddFile("test.dat", new MockFileData(new byte[] { 0x1, 0x2, 0x3, 0x4, 0x5 }));
// 1 + 0 == positive absolute offset
var data = new TestDataType(1);
using (var file = fs.File.OpenRead("test.dat"))
{
await data.ReadAsync(file, 0, new NefsProgress());
}
var expected = new byte[] { 0x2, 0x3, 0x4, 0x5 };
Assert.Equal(expected, data.GetBytes());
}
public void Test_Write()
{
TestDataType data;
FileStream file;
/*
* Test null file stream
*/
data = new TestDataType(0);
try
{
data.Write(null, 0);
}
catch (ArgumentNullException ex)
{
/* Passes if this exception is caught */
Assert.AreEqual(1, 1);
}
/*
* Try to write from a negative actual offset
*/
file = new FileStream(TestHelper.EmptyFile, FileMode.Open);
data = new TestDataType(-4);
try
{
data.Read(file, 0);
/* Fail if this is reached */
Assert.AreEqual(1, 0);
}
catch (InvalidOperationException ex)
{
/* Pass if this exception is caught */
Assert.AreEqual(1, 1);
}
file.Close();
}
public void Test_Offset()
{
TestDataType data;
/*
* Test 0 offset
*/
data = new TestDataType(0);
Assert.AreEqual(0, data.Offset);
/*
* Test positive offset (+123456)
*/
data = new TestDataType(123456);
Assert.AreEqual(123456, data.Offset);
/*
* Test negative offset (-123456);
*/
data = new TestDataType(-123456);
Assert.AreEqual(-123456, data.Offset);
}
/// <summary>
/// load test data to cached
/// </summary>
/// <param name="path_file"></param>
/// <param name="sheet_name"></param>
/// <param name="test_data_type: TestPlan, TestSuite, Share"></param>
public void load_test_data(string path_file, string sheet_name, string test_data_type)
{
try
{
TestDataType type = Utility.ParseEnum <TestDataType>(test_data_type);
if (type == TestDataType.TestPlan)
{
TestDataHelper.LoadTestPlanData(path_file, sheet_name);
}
else if (type == TestDataType.TestSuite)
{
TestDataHelper.LoadTestSuiteData(path_file, sheet_name);
}
else if (type == TestDataType.Share)
{
TestDataHelper.LoadShareData(path_file, sheet_name);
}
}
catch (Exception ex)
{
HandlingException(ex);
}
}
public async Task Write_PositiveDataOffset_WriteSuccess()
{
var expected = new byte[] { 0x5, 0x1, 0x2, 0x3, 0x4 };
var fs = new MockFileSystem();
fs.AddFile("test.dat", new MockFileData(new byte[] { 0x5, 0x5, 0x5, 0x5, 0x5 }));
// 1 + 0 == positive absolute offset
var data = new TestDataType(1);
data.Value = new byte[] { 0x1, 0x2, 0x3, 0x4 };
// Test
using (var file = fs.File.OpenWrite("test.dat"))
{
await data.WriteAsync(file, 0, new NefsProgress());
}
// Verify
var actual = fs.File.ReadAllBytes("test.dat");
Assert.Equal(expected, actual);
}
private static void LoadDataBySheetName(string fileName, string sheetName, TestDataType type)
{
FileStream stream = null;
IExcelDataReader excelReader = null;
try
{
FileInfo fileInfo = new FileInfo(fileName);
var ext = fileInfo.Extension;
stream = File.Open(fileName, FileMode.Open, FileAccess.Read);
if (ext.Equals(".xls", StringComparison.CurrentCultureIgnoreCase))
{
excelReader = ExcelReaderFactory.CreateBinaryReader(stream);
}
else if (ext.Equals(".csv", StringComparison.CurrentCultureIgnoreCase))
{
excelReader = ExcelReaderFactory.CreateCsvReader(stream);
}
else
{
excelReader = ExcelReaderFactory.CreateOpenXmlReader(stream);
}
var rows = excelReader.AsDataSet().Tables[sheetName].Rows;
//==test plan
if (type == TestDataType.TestPlan)
{
for (int i = 0; i < rows.Count; i++)
{
var key = rows[i].ItemArray.GetValue(0).ToString();
var value = rows[i].ItemArray.GetValue(1).ToString();
TestPlanData.Add(new TestDataModel {
Key = key, Value = value
});
}
return;
}
else if (type == TestDataType.Share) //==share data --> skip the 1st row for header
{
for (int i = 1; i < rows.Count; i++)
{
var key = rows[i].ItemArray.GetValue(0).ToString();
var value = rows[i].ItemArray.GetValue(1).ToString();
SharedData.Add(new TestDataModel {
Key = key, Value = value
});
}
return;
}
else if (type == TestDataType.TestSuite)//==test suite
{
TestCaseDataModel testCaseData = null;
TestDataExtraModel extraData = null;
for (int i = 0; i < rows.Count; i++)
{
extraData = null;
var key = rows[i].ItemArray.GetValue(0).ToString();
if (string.IsNullOrEmpty(key))
{
continue;
}
var value = rows[i].ItemArray.GetValue(1) == null ? string.Empty : rows[i].ItemArray.GetValue(1).ToString();
if (key.EqualsText(TestCaseNameKey, true))
{
if (testCaseData == null) //==begin a test case
{
testCaseData = new TestCaseDataModel();
}
else//next test case
{
if (TestSuitData.TestCaseDataList == null)
{
TestSuitData.TestCaseDataList = new List <TestCaseDataModel>();
}
TestSuitData.TestCaseDataList.Add(testCaseData.Clone() as TestCaseDataModel);
testCaseData = new TestCaseDataModel();
continue;
}
}
else if (key.Contains(ExtraDataKey))
{
if (string.IsNullOrEmpty(value))
{
continue;
}
string extraSheetName = value.Split('!').ToList().FirstOrDefault();
extraData = new TestDataExtraModel {
Key = key, DataExtend = excelReader.AsDataSet().Tables[extraSheetName]
};
if (testCaseData.DataExtendList == null)
{
testCaseData.DataExtendList = new List <TestDataExtraModel>();
}
testCaseData.DataExtendList.Add(extraData.Clone() as TestDataExtraModel);
extraData = null;
continue;
}
if (testCaseData == null && string.IsNullOrEmpty(TestSuitData.TestSuiteId)) //==test suite info
{
if (key.EqualsText(TestSuiteIdKey, true))
{
TestSuitData.TestSuiteId = value;
}
if (TestSuitData.DataList == null)
{
TestSuitData.DataList = new List <TestDataModel>();
}
TestSuitData.DataList.Add(new TestDataModel {
Key = key, Value = value
});
}
else if (testCaseData != null)
{
if (testCaseData.DataList == null)
{
testCaseData.DataList = new List <TestDataModel>();
}
if (key.EqualsText(TestCaseIdKey, true))
{
testCaseData.TestCaseId = value;
}
testCaseData.DataList.Add(new TestDataModel {
Key = key, Value = value
});
}
}
//the latest test case
if (testCaseData != null && testCaseData.TestCaseId != string.Empty)
{
if (TestSuitData.TestCaseDataList == null)
{
TestSuitData.TestCaseDataList = new List <TestCaseDataModel>();
}
TestSuitData.TestCaseDataList.Add(testCaseData);
}
return;
}
}
catch (Exception ex)
{
throw ex;
}
finally
{
excelReader.Close();
stream.Close();
}
}
public async Task Read_NullStream_ArgumentNullExceptionThrown()
{
var data = new TestDataType(0);
await Assert.ThrowsAsync <ArgumentNullException>(async() => await data.ReadAsync(null, 0, new NefsProgress()));
}
public void Offset_OffsetInitialized(int offset)
{
var data = new TestDataType(offset);
Assert.Equal(offset, data.Offset);
}
public void Test_readFile()
{
FileStream file;
TestDataType data;
/*
* Test null file stream
*/
data = new TestDataType(0);
try
{
data.Read(null, 0);
}
catch (ArgumentNullException ex)
{
/* Passes if this exception is caught */
Assert.AreEqual(1, 1);
}
/*
* Try to read from a negative actual offset
*/
file = new FileStream(TestHelper.EmptyFile, FileMode.Open);
data = new TestDataType(-4);
try
{
data.Read(file, 0);
/* Fail if this is reached */
Assert.AreEqual(1, 0);
}
catch (InvalidOperationException ex)
{
/* Pass if this exception is caught */
Assert.AreEqual(1, 1);
}
file.Close();
/*
* Try to read past end of file
*/
file = new FileStream(TestHelper.EmptyFile, FileMode.Open);
data = new TestDataType(0);
try
{
data.Read(file, 0);
/* Fail if this is reached */
Assert.AreEqual(1, 0);
}
catch (Exception ex)
{
/* Pass if this exception is caught */
Assert.AreEqual(1, 1);
}
/*
* Valid read tests are handled by classes that inherit DataType.
*/
}
internal static IEnumerable <GenerateMultipleTestContext> GetTestDataByDataType(TestDataType testDataType)
{
switch (testDataType)
{
case TestDataType.ValidData:
return(GetValidData());
case TestDataType.InvalidArgumentExceptionData:
return(GetInvalidArgumentExceptionData());
}
return(default);
