public void TestParserPlusMinus()
{
var filter = "[+]*.cs;*.cpp [-]*Test*;*.c".ToPatternFilter();
var data = new[] { "hoge.cs", "barTest.cs", "foo.cpp", "bar.rb" };
var filter2 = new AndFilter <string>(
new OrFilter <string>(new PatternFilter("*.cs"), new PatternFilter("*.cpp")),
new AndFilter <string>(new NegatePatternFilter("*Test*"), new NegatePatternFilter("*.c")));
Assert.That(filter2.Filter(data), Is.EquivalentTo(new[] { "hoge.cs", "foo.cpp" }), "failed on filter2");
Assert.That(filter.Filter(data), Is.EquivalentTo(filter2.Filter(data)), "failed on filter1");
}
public void Should_be_able_to_AND_two_filters()
{
var eventsInQueue = new Queue <GherkinEvent>();
eventsInQueue.Enqueue(new FeatureEvent(new Feature("feature title"), e => { }));
eventsInQueue.Enqueue(new TagEvent("@tag1", e => { }));
eventsInQueue.Enqueue(new ScenarioEvent(new Scenario("title t1", ""), e => { }));
eventsInQueue.Enqueue(new StepEvent("step", e => { }));
eventsInQueue.Enqueue(new StepEvent("step", e => { }));
eventsInQueue.Enqueue(new TagEvent("@tag1", e => { }));
eventsInQueue.Enqueue(new TagEvent("@tag2", e => { }));
eventsInQueue.Enqueue(new ScenarioEvent(new Scenario("title t2", ""), e => { }));
eventsInQueue.Enqueue(new StepEvent("step", e => { }));
eventsInQueue.Enqueue(new EofEvent(e => { }));
var events = GroupEventsByTag.GroupByTag(eventsInQueue);
var filter1 = new OrFilter(new[] { "@tag1" });
var filter2 = new OrFilter(new[] { "@tag2" });
var filter = new AndFilter(filter1, filter2);
var filteredEvents = filter.Filter(events).ToList();
Assert.AreEqual(4, filteredEvents.Count);
var scenarioEvents = filteredEvents.Where(_ => _ is ScenarioEvent).ToList();
Assert.AreEqual(1, scenarioEvents.Count());
CollectionAssert.AreEqual(new[] { "@tag1", "@tag2" }, scenarioEvents[0].Tags);
}
public void TestPatternInner()
{
var plus = new PatternFilter("*.cs");
var minus = new NegatePatternFilter("*.cs");
var filter = new AndFilter <string>(plus, minus);
var data = new[] { "hoge.cs", "barTest.cs", "foo.cpp", "bar.rb" };
Assert.That(filter.Filter(data), Is.Empty);
}
public async Task <ExcelData> ValidateAsync <Template>(ImportOption importOption)
where Template : class, new()
{
ExcelData excelData = this.GetExcelData <Template>(importOption);
AndFilter andFilter = new AndFilter {
Filters = FiltersFactory.CreateFilters <Template>()
};
FilterContext filterContext = new FilterContext {
TypeFilter = TypeFilterInfoFactory.CreateInstance <Template>()
};
excelData.ExcelDataRows = andFilter.Filter(excelData.ExcelDataRows, filterContext, importOption);
return(await Task.FromResult(excelData));
}
//public DataTable ToTable(string fileUrl, int sheetIndex = 0, int headerRowIndex = 0, int dataRowStartIndex = 1, int dataRowCount = -1)
//{
// IWorkbook workbook;
// using (FileStream stream = new FileStream(fileUrl, FileMode.Open, FileAccess.Read))
// {
// workbook = new HSSFWorkbook(stream);
// }
// ISheet sheet = workbook.GetSheetAt(sheetIndex);
// DataTable dt = new DataTable(sheet.SheetName);
// // 处理表头
// IRow headerRow = sheet.GetRow(headerRowIndex);
// foreach (ICell headerCell in headerRow)
// {
// dt.Columns.Add(headerCell.ToString());
// }
// //默认转换所有数据
// var dataRowStopIndex = sheet.PhysicalNumberOfRows - 1;
// //只转换指定数量数据
// if (dataRowCount > -1)
// {
// dataRowStopIndex = dataRowStartIndex + dataRowCount;
// }
// //转换
// for (int i = dataRowStartIndex; i < dataRowStopIndex; i++)
// {
// var row = sheet.GetRow(i);
// if (row != null)
// {
// DataRow dataRow = dt.NewRow();
// dataRow.ItemArray = row.Cells.Select(c => c.ToString()).ToArray();
// dt.Rows.Add(dataRow);
// }
// }
// return dt;
//}
/// <summary>
/// 导入
/// </summary>
/// <typeparam name="T">模板类</typeparam>
/// <param name="fileUrl">Excel文件绝对地址</param>
/// <returns></returns>
public Task <List <ExcelDataRow> > ValidateAsync <T>(ImportOption importOption) where T : class, new()
{
var excelData = GetExcelData <T>(importOption);
if (importOption.MappingDictionary != null)
{
excelData.Data = MappingHeaderDictionary(excelData.Data, importOption.MappingDictionary);
}
AndFilter andFilter = new AndFilter()
{
filters = FiltersFactory.CreateFilters <T>(excelData.Header)
};
FilterContext context = new FilterContext()
{
TypeFilterInfo = TypeFilterInfoFactory.CreateInstance(typeof(T), excelData.Header)
};
excelData.Data = andFilter.Filter(excelData.Data, context, importOption);
return(Task.FromResult(excelData.Data));
}
public void TestNegatePatternAndFilter(string[] source, string negaterPattern1, string negatePattern2, string[] expected)
{
var filter = new AndFilter <string>(new NegatePatternFilter(negaterPattern1), new NegatePatternFilter(negatePattern2));
Assert.That(filter.Filter(source), Is.EquivalentTo(expected));
}
