public void RulesConstructor_WhenSuccessful_InitializesProperties()
{
var filterRules = new[] { new FilterRule<object>(FilterRuleType.Exclusion, new AnyFilter<object>()), new FilterRule<object>(FilterRuleType.Inclusion, new NoneFilter<object>()) };
var filterSet = new FilterSet<object>(filterRules);
Assert.AreElementsEqual(filterRules, filterSet.Rules);
}
/// <summary>
/// FilterSet speichern
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void saveFilterSet_Click(object sender, RoutedEventArgs e)
{
// Prüfe ob für das Statistiken/Listen-Modul
if (this.useForListModule && string.IsNullOrEmpty(tbName.Text))
{
MessageBoxEnhanced.Error(IniParser.GetSetting("FORMLETTER", "noSetNameSpecified"));
return;
}
// Keine leeren Filtersets zulassen
if (!(listBox1.Items.Count > 0))
{
return;
}
// Lese Filter aus Filter-Liste
foreach (var subitem in listBox1.Items)
{
currentFilterSet.addFilter(subitem as FilterModel);
}
// Wenn nicht für Listen-Modul, lege FilterSet im Speicher ab
if (!this.useForListModule)
{
allFilterSets.Add(currentFilterSet);
}
// Für das Listen/Statistiken-Modul wird das FilterSet direkt in die Datenbank gespeichert
if (this.useForListModule)
{
string name = tbName.Text;
try
{
int filterSetID = FilterSet.Add(name, currentFilterSet.linkingType);
// Bearbeite alle Filter zu jedem Set
foreach (var filter in currentFilterSet.filterList)
{
string table = filter.group.ToString();
string type = filter.criterion.ToString();
string operation = filter.operation.ToString();
string value = filter.value;
int filterID = Filter.Add(filterSetID, table, type, operation, value);
}
}
catch
{
}
}
listBox1.IsEnabled = false;
listBox2.IsEnabled = true;
btDeleteSetButton.IsEnabled = true;
refreshListBoxWithAllFilterSets();
currentFilterSet = null;
clearForm();
tbName.Clear();
deactivateForm();
}
/// <summary>
/// Das Event loest eine Suche nach Datensaetzen aus und das DataGrid wird an Anzuzeigende Daten angepasst
/// </summary>
private void bSearchSavedFilter_Click(object sender, RoutedEventArgs e)
{
Cursor = Cursors.Wait;
IEnumerable <FilterSet> filterSets = FilterSet.GetFilterSets(null, null, cBSavedFilter.Text);
search(filterSets);
Cursor = Cursors.Arrow;
}
public async Task Execute_FailWithNoSiteModel()
{
var filter = new FilterSet(new CombinedFilter());
var request = new QMTileExecutor(new Guid(), filter, 0, 0, 19, 0, false, Guid.NewGuid());
var result = await request.ExecuteAsync();
result.Should().BeFalse();
}
/// <summary>
/// Das Event aktiviert/deaktiviert verschiedene Buttons und sucht sofort nach Datensaetzen sobald ein Filter ausgewaehlt wurde
/// </summary>
private void cBSavedFilter_DropDownClosed(object sender, EventArgs e)
{
// Cursor auf arbeitenden Kreis setzen, um zu zeigen dass das Programm was macht
Cursor = Cursors.Wait;
// Suchen-, Drucken-, Loeschenbutton deaktivieren wenn kein Filter ausgewaehlt wurde
if (cBSavedFilter.Text == "")
{
bSearchSavedFilter.IsEnabled = false;
bDeleteSavedFilter.IsEnabled = false;
bPrint.IsEnabled = false;
displayedDataPage.resetAll();
lCount.Content = "";
dGSavedFilter.ItemsSource = null;
dGSavedFilter.Columns.Clear();
}
// Suchen-, Loeschenbutton aktivieren wenn ein Filter ausgewaehlt wurde und automatisch suchen mit Defaultwerten
else
{
bSearchSavedFilter.IsEnabled = true;
bDeleteSavedFilter.IsEnabled = true;
displayedDataPage.resetAll();
// Die ersten beiden Comboboxen werden mit den Defaultwerten belegt
((ComboBox)displayedDataComboBoxes[0]).Items.Add("Name");
((ComboBox)displayedDataComboBoxes[0]).SelectedItem = "Name";
((ComboBox)displayedDataComboBoxes[0]).IsEnabled = true;
((ComboBox)displayedDataComboBoxes[1]).Items.Add("Adresse");
((ComboBox)displayedDataComboBoxes[1]).SelectedItem = "Adresse";
((ComboBox)displayedDataComboBoxes[1]).IsEnabled = true;
((ComboBox)displayedDataComboBoxes[1]).Visibility = Visibility.Visible;
((ComboBox)displayedDataComboBoxes[2]).IsEnabled = true;
((ComboBox)displayedDataComboBoxes[2]).Visibility = Visibility.Visible;
// Comboboxen für Anzuzeigende Daten fuellen, je nachdem ob die Filter mit Kunde, Sponsor, Mitarbeiter ist
IEnumerable <FilterSet> filterSets = FilterSet.GetFilterSets(null, null, cBSavedFilter.Text);
FilterSet filterSet = filterSets.ElementAt(0);
IEnumerable <Filter> filters = Filter.GetFilters(null, filterSet.FilterSetID, null, null);
switch (filters.ElementAt(0).Table)
{
case "Kunde":
displayedDataPage.setDisplayableData(displayableDataPassHolder);
break;
case "Sponsor":
displayedDataPage.setDisplayableData(displayableDataSponsor);
break;
case "Mitarbeiter":
displayedDataPage.setDisplayableData(displayableDataTeamMember);
break;
}
search(filterSets);
}
//Cursor zuruecksetzen
Cursor = Cursors.Arrow;
}
public void SimpleConstructor_WhenSuccessful_InitializesProperties()
{
var filter = new AnyFilter<object>();
var filterSet = new FilterSet<object>(filter);
Assert.Count(1, filterSet.Rules);
Assert.AreEqual(FilterRuleType.Inclusion, filterSet.Rules[0].RuleType);
Assert.AreEqual(filter, filterSet.Rules[0].Filter);
}
public void SimpleConstructor_WhenSuccessful_InitializesProperties()
{
var filter = new AnyFilter <object>();
var filterSet = new FilterSet <object>(filter);
Assert.Count(1, filterSet.Rules);
Assert.AreEqual(FilterRuleType.Inclusion, filterSet.Rules[0].RuleType);
Assert.AreEqual(filter, filterSet.Rules[0].Filter);
}
/// <summary>
/// Initializes a new instance of the <see cref="MbUnitTask"/> class.
/// </summary>
/// <param name="buildEnvironment">The build environment.</param>
public MbUnitTask(IBuildEnvironment buildEnvironment)
{
BuildEnvironment = buildEnvironment;
FilterAuthors = new IncludeSet();
FilterCategories = new FilterSet();
FilterNamespaces = new IncludeSet();
FilterTypes = new IncludeSet();
}
void Upload()
{
IPhoto [] items = dialog.Items;
string [] captions = dialog.Captions;
dialog.StoreCaption();
long sent_bytes = 0;
FilterSet filters = new FilterSet();
filters.Add(new JpegFilter());
filters.Add(new ResizeFilter((uint)size));
for (int i = 0; i < items.Length; i++)
{
try {
IPhoto item = items [i];
FileInfo file_info;
Log.DebugFormat("uploading {0}", i);
progress_dialog.Message = string.Format(Catalog.GetString("Uploading picture \"{0}\" ({1} of {2})"), item.Name, i + 1, items.Length);
progress_dialog.ProgressText = string.Empty;
progress_dialog.Fraction = i / (double)items.Length;
FilterRequest request = new FilterRequest(item.DefaultVersion.Uri);
filters.Convert(request);
file_info = new FileInfo(request.Current.LocalPath);
album.Upload(captions [i] ?? "", request.Current.LocalPath);
sent_bytes += file_info.Length;
}
catch (Exception e) {
progress_dialog.Message = string.Format(Catalog.GetString("Error Uploading To Facebook: {0}"), e.Message);
progress_dialog.ProgressText = Catalog.GetString("Error");
Log.DebugException(e);
if (progress_dialog.PerformRetrySkip())
{
i--;
}
}
}
progress_dialog.Message = Catalog.GetString("Done Sending Photos");
progress_dialog.Fraction = 1.0;
progress_dialog.ProgressText = Catalog.GetString("Upload Complete");
progress_dialog.ButtonLabel = Gtk.Stock.Ok;
var li = new LinkButton("http://www.facebook.com/group.php?gid=158960179844&ref=mf", Catalog.GetString("Visit F-Spot group on Facebook"));
progress_dialog.VBoxPackEnd(li);
li.ShowAll();
}
public static FilterValueSetParam[] GetFilterMulti(EPStatementSPI statementSPI)
{
FilterServiceSPI filterServiceSPI = (FilterServiceSPI)statementSPI.StatementContext.FilterService;
FilterSet set = filterServiceSPI.Take(Collections.SingletonSet(statementSPI.StatementId));
Assert.AreEqual(1, set.Filters.Count);
FilterValueSet valueSet = set.Filters[0].FilterValueSet;
return(valueSet.Parameters[0]);
}
public void If_applied_filter_set_is_none_filter_then_the_root_should_be_unchecked()
{
var testTreeNode = new TestTreeNode("root", "root");
testTreeModel.Stub(ttm => ttm.Root).Return(testTreeNode);
var filterSet = new FilterSet<ITestDescriptor>(new NoneFilter<ITestDescriptor>());
filterService.ApplyFilterSet(filterSet);
Assert.AreEqual(CheckState.Unchecked, testTreeNode.CheckState);
}
public SearchResult <TEntityType> DoSearch <TEntityType>(
IQueryable <TEntityType> query,
FilterSet filter,
List <IMapAFilter <TEntityType> > mappings
) where TEntityType : class
{
var mappingDef = new MappingCollection <TEntityType>(mappings);
return(DoSearch(query, filter, mappingDef));
}
public WidgetV2()
{
Locations = new LocationSet();
CredentialFilters = new FilterSet();
OrganizationFilters = new FilterSet();
AssessmentFilters = new FilterSet();
LearningOpportunityFilters = new FilterSet();
WidgetColors = new List <ColorPair>();
InitializeLists(this);
}
/// <summary>
/// Fuellt die Combobox "cBSavedFilter" mit allen Filtern aus der Datenbank die keinem Serienbrief zugeordnet sind.
/// </summary>
private void fillSavedFilter()
{
// Zunaechst wird die Combobox geleert
cBSavedFilter.Items.Clear();
// Jedes FilterSet bei dem der Name leer ist wird hinzugefuegt (FilterSet ohne Namen gehoeren zu Serienbriefen)
foreach (FilterSet filterSet in FilterSet.GetFilterSets().Where(p => p.Name != ""))
{
cBSavedFilter.Items.Add(filterSet.Name);
}
}
/// <summary>
/// Удаление выбранного фильтра
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void DeleteFilterButtonClick(object sender, EventArgs e)
{
// Проброс в статкласс.
FilterSet.DeleteFilter();
UpdateForm();
// Выбираем последний элемент
FilterSet.ChooseFilter(listFilters.Items.Count - 1);
}
private void SetupTest()
{
var tagFiles = new[]
{
Path.Combine(TestHelper.CommonTestDataPath, "TestTAGFile-QMesh.tag"),
};
siteModel = DITAGFileAndSubGridRequestsFixture.BuildModel(tagFiles, out _);
var boundary = new List <Fence>()
{
new Fence()
};
boundary[0].Points.Add(new FencePoint(2700.20170260547, 1225.08445683629, 0.0));
boundary[0].Points.Add(new FencePoint(2700.16517351542, 1224.38744027628, 0.0));
boundary[0].Points.Add(new FencePoint(2700.10136538994, 1223.16990871245, 0.0));
boundary[0].Points.Add(new FencePoint(2889.7599542129, 1178.36648123432, 0.0));
// Mocked ConvertCoordinates expected result.
var neeCoords = new XYZ[boundary[0].Points.Count];
// mock tile boundary within model extents
//WS
neeCoords[0].X = Math.Round(2847.26, DECIMALS);
neeCoords[0].Y = Math.Round(1219.93, DECIMALS);
//EN
neeCoords[1].X = Math.Round(2879.11, DECIMALS);
neeCoords[1].Y = Math.Round(1276.37, DECIMALS);
//WN
neeCoords[2].X = Math.Round(2847.26, DECIMALS);
neeCoords[2].Y = Math.Round(1276.37, DECIMALS);
// ES
neeCoords[3].X = Math.Round(2879.11, DECIMALS);
neeCoords[3].Y = Math.Round(1219.93, DECIMALS);
var llhCoords = new XYZ[2500];
for (int i = 0; i < 2500; i++)
{
llhCoords[i].X = Math.Round(2847.26 + i, DECIMALS);
llhCoords[i].Y = Math.Round(1219.93 + i, DECIMALS);
}
var expectedCoordinateConversionResult = neeCoords.ToCoreX_XYZ();
var expectedCoordinateConversionResult2 = llhCoords.ToCoreX_XYZ();
// LL to NEE
var convertCoordinatesMock = new Mock <ICoreXWrapper>();
convertCoordinatesMock.Setup(x => x.LLHToNEE(It.IsAny <string>(), It.IsAny <CoreXModels.XYZ[]>(), CoreX.Types.InputAs.Radians)).Returns(expectedCoordinateConversionResult);
convertCoordinatesMock.Setup(x => x.NEEToLLH(It.IsAny <string>(), It.IsAny <CoreXModels.XYZ[]>(), CoreX.Types.ReturnAs.Radians)).Returns(expectedCoordinateConversionResult2);
DIBuilder.Continue().Add(x => x.AddSingleton(convertCoordinatesMock.Object)).Complete();
filter = new FilterSet(new CombinedFilter());
}
public void If_applied_filter_set_is_none_filter_then_the_root_should_be_unchecked()
{
var testTreeNode = new TestTreeNode("root", "root");
testTreeModel.Stub(ttm => ttm.Root).Return(testTreeNode);
var filterSet = new FilterSet <ITestDescriptor>(new NoneFilter <ITestDescriptor>());
filterService.ApplyFilterSet(filterSet);
Assert.AreEqual(CheckState.Unchecked, testTreeNode.CheckState);
}
/// <summary>
/// Checks if all Filter in a FilterSet are valid
/// </summary>
/// <param name="fS"></param>
/// <returns></returns>
private bool FilterValidation(FilterSet fS)
{
foreach (FilterClass fC in fS.Filter)
{
if (FilterValidation(fC) == false)
{
return(false);
}
}
return(true);
}
private void Clear()
{
FileName = string.Empty;
Filters = new FilterSet(new CombinedFilter());
CoordType = CoordType.Northeast;
OutputType = OutputTypes.PassCountLastPass;
UserPreferences = new CSVExportUserPreferences();
MappedMachines = new List <CSVExportMappedMachine>();
RestrictOutputSize = false;
RawDataAsDBase = false;
}
public FiltersWindow(int eventId)
{
this.eventId = eventId;
this.filterVM = new FilterVM(eventId);
this.newFilter = null;
this.filterIds = new Dictionary <int, int>();
this.stopProcessSelectionChanged = new Dictionary <string, bool>();
this.deletedFilters = new HashSet <int>();
InitializeComponent();
InitializeFilterScreen();
}
public void DeleteFilter(int filterId)
{
FilterSet filterToDelete = this._repostitoryFactory.GetFilterRepository(this._dbContext).GetById(filterId);
List <RuleSet> rulesToDelete = this._repostitoryFactory.GetRuleRepository(this._dbContext).GetAll()
.Where(r => r.FilterID_Filter == filterToDelete.ID_Filter).ToList();
foreach (RuleSet item in rulesToDelete)
{
DeleteRule(item.ID_Rule);
}
this._repostitoryFactory.GetFilterRepository(this._dbContext).Delete(filterToDelete);
}
private void Intersect(FilterSet result, IFilterSet filtered, ref bool inited)
{
if (inited)
{
result.IntersectWith(filtered);
}
else
{
result.Add(filtered);
inited = true;
}
}
public void Test_RequestorUtilities_CreateIntermediaries_MultipleFilters_WithOneOfTwoSurveyedSurfacesFilteredByTime_NoSurveyedSurfaceExclusions(int filterCount)
{
var ru = new RequestorUtilities();
ISurveyedSurfaces surveyedSurfaces = DIContext.Obtain <ISurveyedSurfaces>();
// Create two surveyed surfaces that bracket current time by one day either side and set the filter end time to be current time
// which will cause only one surveyed surface to be filtered
Guid ssGuid1 = Guid.NewGuid();
var ss1 = surveyedSurfaces.AddSurveyedSurfaceDetails(ssGuid1, DesignDescriptor.Null(), DateTime.UtcNow.AddDays(-1), BoundingWorldExtent3D.Null());
Guid ssGuid2 = Guid.NewGuid();
var ss2 = surveyedSurfaces.AddSurveyedSurfaceDetails(ssGuid2, DesignDescriptor.Null(), DateTime.UtcNow.AddDays(+1), BoundingWorldExtent3D.Null());
var mockGrid = new Mock <IServerSubGridTree>();
mockGrid.Setup(x => x.CellSize).Returns(SubGridTreeConsts.DefaultCellSize);
var mockSiteModel = new Mock <ISiteModel>();
mockSiteModel.Setup(x => x.SurveyedSurfacesLoaded).Returns(true);
mockSiteModel.Setup(x => x.SurveyedSurfaces).Returns(surveyedSurfaces);
mockSiteModel.Setup(x => x.Grid).Returns(mockGrid.Object);
ICombinedFilter[] filters = Enumerable.Range(1, filterCount).Select(x =>
{
var filter = new CombinedFilter
{
AttributeFilter =
{
HasTimeFilter = true,
StartTime = Consts.MIN_DATETIME_AS_UTC,
EndTime = DateTime.UtcNow
}
};
return(filter);
}).ToArray();
IFilterSet filterSet = new FilterSet(filters);
var intermediaries = ru.ConstructRequestorIntermediaries(mockSiteModel.Object, filterSet, true, GridDataType.Height);
intermediaries.Length.Should().Be(filters.Length);
for (int i = 0; i < intermediaries.Length; i++)
{
intermediaries[i].Filter.Should().Be(filters[i]);
intermediaries[i].FilteredSurveyedSurfaces.Should().Equal(new List <ISurveyedSurface> {
ss1
});
intermediaries[i].CacheContexts[0].Should().NotBeNull();
intermediaries[i].surfaceElevationPatchRequest.Should().Be(_fixture.SurfaceElevationPatchRequest);
}
}
public async Task UpdateFilterSetAsync(FilterSet filterSet)
{
var queryParameters = new DynamicParameters();
queryParameters.Add("@FilterSetId", filterSet.FilterSetId);
queryParameters.Add("@Name", filterSet.Name);
queryParameters.Add("@IsSharedWithAllCompanies", filterSet.IsSharedWithAllCompanies);
queryParameters.Add("@IsSharedWithAllUsers", filterSet.IsSharedWithAllUsers);
queryParameters.Add("@listFilters", ToArrayTVP(filterSet.Filters));
await ExecuteNonQueryAsync(StoredProcedureNames.UpdateFilterSet, queryParameters, true);
}
public void Execute_should_call_ApplyFilterSet_on_TestController()
{
var filterService = MockRepository.GenerateStub <IFilterService>();
var filterSet = new FilterSet <ITestDescriptor>(new NoneFilter <ITestDescriptor>());
var cmd = new ApplyFilterCommand(filterService)
{
FilterSet = filterSet
};
cmd.Execute(MockProgressMonitor.Instance);
filterService.AssertWasCalled(tc => tc.ApplyFilterSet(filterSet));
}
public void Evaluate_Always_ConsidersRulesInOrder(FilterSetResult expectedResult, FilterRuleType[] ruleTypes, bool[] states)
{
FilterRule <object>[] filterRules = new FilterRule <object> [ruleTypes.Length];
for (int i = 0; i < ruleTypes.Length; i++)
{
filterRules[i] = new FilterRule <object>(ruleTypes[i],
states[i] ? (Filter <object>) new AnyFilter <object>() : new NoneFilter <object>());
}
FilterSet <object> filterSet = new FilterSet <object>(filterRules);
Assert.AreEqual(expectedResult, filterSet.Evaluate(null));
}
public void ToFilterSetExpr_Always_FormatsRulesInOrder(string expectedResult, FilterRuleType[] ruleTypes, bool[] states)
{
FilterRule <object>[] filterRules = new FilterRule <object> [ruleTypes.Length];
for (int i = 0; i < ruleTypes.Length; i++)
{
filterRules[i] = new FilterRule <object>(ruleTypes[i],
states[i] ? (Filter <object>) new AnyFilter <object>() : new NoneFilter <object>());
}
FilterSet <object> filterSet = new FilterSet <object>(filterRules);
Assert.AreEqual(expectedResult, filterSet.ToFilterSetExpr());
}
private static bool EvaluateNode(Node node, FilterSet<ITestDescriptor> filterSet)
{
var result = filterSet.Evaluate((ITestDescriptor)node);
if (result == FilterSetResult.Include)
{
node.CheckState = CheckState.Checked;
return true;
}
node.CheckState = CheckState.Unchecked;
return false;
}
public void RunFinished_is_fired_when_running_tests()
{
var progressMonitor = MockProgressMonitor.Instance;
var filter = new FilterSet <ITestDescriptor>(new NoneFilter <ITestDescriptor>());
filterService.Stub(fs => fs.GenerateFilterSetFromSelectedTests()).Return(filter);
optionsController.Stub(oc => oc.TestRunnerExtensions).Return(new BindingList <string>(new List <string>()));
StubTestRunnerFactory();
testController.Run(false, progressMonitor, new List <string>());
eventAggregator.AssertWasCalled(ea => ea.Send(Arg.Is(testController), Arg <RunFinished> .Is.Anything));
}
private static bool EvaluateNode(Node node, FilterSet <ITestDescriptor> filterSet)
{
var result = filterSet.Evaluate((ITestDescriptor)node);
if (result == FilterSetResult.Include)
{
node.CheckState = CheckState.Checked;
return(true);
}
node.CheckState = CheckState.Unchecked;
return(false);
}
private static void ApplyFilters(Node node, FilterSet<ITestDescriptor> filterSet)
{
if (node is ITestDescriptor)
{
var match = EvaluateNode(node, filterSet);
if (match) return;
}
foreach (var child in node.Nodes)
{
ApplyFilters(child, filterSet);
}
}
public void Execute_should_call_ApplyFilterSet_on_TestController()
{
var filterService = MockRepository.GenerateStub<IFilterService>();
var filterSet = new FilterSet<ITestDescriptor>(new NoneFilter<ITestDescriptor>());
var cmd = new ApplyFilterCommand(filterService)
{
FilterSet = filterSet
};
cmd.Execute(MockProgressMonitor.Instance);
filterService.AssertWasCalled(tc => tc.ApplyFilterSet(filterSet));
}
/// <summary>
/// This method creates a new event list for the context.
/// </summary>
/// <param name="updateRate"> The update rate for the list. </param>
/// <param name="bufferingRate"> The buffering rate for the list. 0 if not used. </param>
/// <param name="filterSet"> The filter set for the list. Null if not used. </param>
/// <returns> Returns the new data list. </returns>
public IXiEventListProxy NewEventList(uint updateRate, uint bufferingRate, FilterSet filterSet)
{
if (_disposed)
{
throw new ObjectDisposedException("Cannot access a disposed XiServerProxy.");
}
if (_context is null)
{
throw new XiServerNotExistException();
}
return(new XiEventList(_context, updateRate, bufferingRate, filterSet));
}
public void Test_CellPassesRequestArgument_ApplicationService_CreationWithArgs()
{
Guid siteModelID = Guid.NewGuid();
bool coordsAreGrid = false;
XYZ latLngPoint = new XYZ(12345.6789, 98765.4321);
IFilterSet filters = new FilterSet();
var arg = new CellPassesRequestArgument_ApplicationService(siteModelID, coordsAreGrid, latLngPoint, filters);
arg.Should().NotBeNull();
arg.ProjectID.Should().Be(siteModelID);
arg.CoordsAreGrid.Should().Be(coordsAreGrid);
arg.Point.Should().Be(latLngPoint);
arg.Filters.Should().Be(filters);
}
public async void Execute_EmptySiteModel_ReturnEmptyTile()
{
var siteModel = DITAGFileAndSubGridRequestsWithIgniteFixture.NewEmptyModel();
var filter = new FilterSet(new CombinedFilter());
var request = new QMTileExecutor(siteModel.ID, filter, 0, 0, 19, DisplayMode, false, Guid.NewGuid());
await request.ExecuteAsync();
request.ResultStatus.Should().NotBe(RequestErrorStatus.Unknown);
var QMTileResponse = request.QMTileResponse;
//QMTileResponse.data.Should().HaveCount(164); // Should return an empty tile
// Todo why OS makes a difference for this test
QMTileResponse.data.Should().HaveCountGreaterOrEqualTo(162);
QMTileResponse.data.Should().HaveCountLessOrEqualTo(164);
}
public void TestRunnerExtensions_are_found_from_Project()
{
var progressMonitor = MockProgressMonitor.Instance;
var filter = new FilterSet <ITestDescriptor>(new NoneFilter <ITestDescriptor>());
filterService.Stub(ttm => ttm.GenerateFilterSetFromSelectedTests()).Return(filter);
var testRunnerExtensions = new BindingList <string>(new List <string>());
optionsController.Stub(oc => oc.TestRunnerExtensions).Return(testRunnerExtensions);
StubTestRunnerFactory();
testController.Run(false, progressMonitor, new List <string>(new[] { "DebugExtension, Gallio" }));
testRunner.AssertWasCalled(tr => tr.RegisterExtension(Arg <DebugExtension> .Is.Anything));
}
public void ApplyFilterSet(FilterSet<ITestDescriptor> filterSet)
{
if (testTreeModel.Root == null)
return;
var root = testTreeModel.Root;
if (filterSet.IsEmpty)
{
root.CheckState = CheckState.Checked;
}
else
{
ApplyFilters(root, filterSet);
}
}
public virtual string FilterString( FilterSet fs )
{
if( fs.Rules.Count == 0 )
return null;
List<string> items = new List<string>();
foreach( IFilterRule r in fs.Rules )
{
if( r is FilterInfo )
{
items.Add( FilterString( r as FilterInfo) );
}
else if( r is FilterSet )
{
items.Add( "(" + FilterString( r as FilterSet ) + ")" );
}
}
return items.Join( fs.JoinOperator == FilterJoinOperator.And ? " AND " : " OR " );
}
/// <inheritdoc />
public ITestCommand BuildCommands(TestModel testModel, FilterSet<ITestDescriptor> filterSet, bool exactFilter, ITestContextManager contextManager)
{
if (testModel == null)
throw new ArgumentNullException("testModel");
if (filterSet == null)
throw new ArgumentNullException("filterSet");
if (contextManager == null)
throw new ArgumentNullException("contextManager");
var commands = new Dictionary<Test, ManagedTestCommand>();
bool hasExplicitAncestor = ! filterSet.HasInclusionRules;
ManagedTestCommand rootCommand = CreateFilteredClosure(commands, testModel.RootTest, filterSet, exactFilter,
hasExplicitAncestor, contextManager);
if (rootCommand == null)
return null;
var siblingDependencies = new MultiMap<ManagedTestCommand, ManagedTestCommand>();
PopulateCommandDependencies(commands, siblingDependencies);
SortChildren(rootCommand, siblingDependencies);
return rootCommand;
}
public void Run_Test()
{
var progressMonitor = MockProgressMonitor.Instance;
var filter = new FilterSet<ITestDescriptor>(new NoneFilter<ITestDescriptor>());
filterService.Stub(fs => fs.GenerateFilterSetFromSelectedTests()).Return(filter);
optionsController.Stub(oc => oc.TestRunnerExtensions).Return(new BindingList<string>(new List<string>()));
StubTestRunnerFactory();
var testPackage = new TestPackage();
testPackage.AddFile(new FileInfo("test"));
testController.SetTestPackage(testPackage);
testController.Run(false, progressMonitor, new List<string>());
testRunner.AssertWasCalled(tr => tr.Run(Arg<TestPackage>.Matches(tpc => tpc.Files.Count == 1),
Arg<TestExplorationOptions>.Is.Anything,
Arg<TestExecutionOptions>.Matches(teo => ((teo.FilterSet == filter) && !teo.ExactFilter)),
Arg.Is(progressMonitor)));
}
/// <summary>
/// Create a new Binding
/// </summary>
/// <param name="nm">The name of this Binding</param>
/// <param name="ttype">The type of target this Binding has</param>
/// <param name="btype">To what this Binding binds</param>
/// <param name="fset">The Filterset defining this Binding</param>
/// <param name="target">To where this Binding binds</param>
public Binding(string nm, TargetType ttype, BindingType btype, FilterSet fset, string target)
{
this.Name = nm;
this.Target = target;
this.TargetType = ttype;
this.BindingType = btype;
this.filterSet = fset;
this.IsValid = true;
}
private void SetTestFilter(IEnumerable<TestCase> tests)
{
var filters = tests.Select(t => new EqualityFilter<string>(t.GetPropertyValue(testIdProperty).ToString())).ToArray();
var filterSet = new FilterSet<ITestDescriptor>(new IdFilter<ITestDescriptor>(new OrFilter<string>(filters)));
launcher.TestExecutionOptions.FilterSet = filterSet;
}
public void IsEmpty_WhenAtLeastOneRule_ReturnsFalse()
{
var filterSet = new FilterSet<object>(new AnyFilter<object>());
Assert.IsFalse(filterSet.IsEmpty);
}
private FacadeTestRunState Run(IFacadeTestListener testListener, string assemblyPath, Filter<ITestDescriptor> filter, FacadeOptions facadeOptions)
{
if (testListener == null)
throw new ArgumentNullException(@"testListener");
if (assemblyPath == null)
throw new ArgumentNullException("assemblyPath");
if (facadeOptions == null)
throw new ArgumentNullException("facadeOptions");
ILogger logger = new FilteredLogger(new TDNetLogger(testListener), LogSeverity.Info);
try
{
RuntimeAccessor.Instance.AddLogListener(logger);
var filterRules = new List<FilterRule<ITestDescriptor>>();
switch (facadeOptions.FilterCategoryMode)
{
case FacadeFilterCategoryMode.Disabled:
filterRules.Add(new FilterRule<ITestDescriptor>(FilterRuleType.Inclusion, filter));
break;
case FacadeFilterCategoryMode.Include:
filterRules.Add(new FilterRule<ITestDescriptor>(FilterRuleType.Inclusion,
new AndFilter<ITestDescriptor>(new[] { filter, ToCategoryFilter(facadeOptions.FilterCategoryNames) })));
break;
case FacadeFilterCategoryMode.Exclude:
filterRules.Add(new FilterRule<ITestDescriptor>(FilterRuleType.Exclusion, ToCategoryFilter(facadeOptions.FilterCategoryNames)));
filterRules.Add(new FilterRule<ITestDescriptor>(FilterRuleType.Inclusion, filter));
break;
}
var filterSet = new FilterSet<ITestDescriptor>(filterRules);
launcher.Logger = logger;
launcher.ProgressMonitorProvider = new LogProgressMonitorProvider(logger);
launcher.TestExecutionOptions.FilterSet = filterSet;
launcher.TestProject.TestRunnerFactoryName = StandardTestRunnerFactoryNames.IsolatedAppDomain;
launcher.TestProject.AddTestRunnerExtension(new TDNetExtension(testListener)); // This monitor will inform the user in real-time what's going on
launcher.TestProject.TestPackage.AddFile(new FileInfo(assemblyPath));
string assemblyDirectory = Path.GetDirectoryName(assemblyPath);
launcher.TestProject.TestPackage.ApplicationBaseDirectory = new DirectoryInfo(assemblyDirectory);
launcher.TestProject.TestPackage.WorkingDirectory = new DirectoryInfo(assemblyDirectory);
TestLauncherResult result = RunLauncher(launcher);
string reportDirectory = GetReportDirectory(logger);
if (reportDirectory != null)
{
var reportFormatterOptions = new ReportFormatterOptions();
var preferenceManager = (TDNetPreferenceManager)RuntimeAccessor.ServiceLocator.ResolveByComponentId("TDNetRunner.PreferenceManager");
var reportFormat = preferenceManager.ReportSettings.DetermineReportFormat(result.Report);
result.GenerateReports(reportDirectory, Path.GetFileName(assemblyPath), ReportArchive.Normal,
new[] { reportFormat }, reportFormatterOptions,
RuntimeAccessor.ServiceLocator.Resolve<IReportManager>(), NullProgressMonitor.CreateInstance());
// This will generate a link to the generated report
if (result.ReportDocumentPaths.Count != 0)
{
Uri rawUrl = new Uri(result.ReportDocumentPaths[0]);
string displayUrl = "file:///" + rawUrl.LocalPath.Replace(" ", "%20").Replace(@"\", "/");
// TDNet just prints the link on its own but it's not always clear to users what it represents.
// testListener.TestResultsUrl(displayUrl);
testListener.WriteLine("\nTest Report: " + displayUrl, FacadeCategory.Info);
}
}
// Inform no tests run, if necessary.
if (result.ResultCode == ResultCode.NoTests)
{
InformNoTestsWereRun(testListener, Resources.MbUnitTestRunner_NoTestsFound);
}
else if (result.Statistics.TestCount == 0)
{
InformNoTestsWereRun(testListener, null);
}
return GetTestRunState(result);
}
finally
{
RuntimeAccessor.Instance.RemoveLogListener(logger);
}
}
public void ToFilterSetExpr_Always_FormatsRulesInOrder(string expectedResult, FilterRuleType[] ruleTypes, bool[] states)
{
FilterRule<object>[] filterRules = new FilterRule<object>[ruleTypes.Length];
for (int i = 0; i < ruleTypes.Length; i++)
filterRules[i] = new FilterRule<object>(ruleTypes[i],
states[i] ? (Filter<object>)new AnyFilter<object>() : new NoneFilter<object>());
FilterSet<object> filterSet = new FilterSet<object>(filterRules);
Assert.AreEqual(expectedResult, filterSet.ToFilterSetExpr());
}
public void HasInclusionRules_WhenAtLeastOneInclusionRule_ReturnsTrue()
{
var filterSet = new FilterSet<object>(new AnyFilter<object>());
Assert.IsTrue(filterSet.HasInclusionRules);
}
public void Evaluate_Always_ConsidersRulesInOrder(FilterSetResult expectedResult, FilterRuleType[] ruleTypes, bool[] states)
{
FilterRule<object>[] filterRules = new FilterRule<object>[ruleTypes.Length];
for (int i = 0; i < ruleTypes.Length; i++)
filterRules[i] = new FilterRule<object>(ruleTypes[i],
states[i] ? (Filter<object>)new AnyFilter<object>() : new NoneFilter<object>());
FilterSet<object> filterSet = new FilterSet<object>(filterRules);
Assert.AreEqual(expectedResult, filterSet.Evaluate(null));
}
public void HasInclusionRules_WhenOnlyExclusionRules_ReturnsFalse()
{
var filterSet = new FilterSet<object>(new[] { new FilterRule<object>(FilterRuleType.Exclusion, new AnyFilter<object>()) });
Assert.IsFalse(filterSet.HasInclusionRules);
}
private ManagedTestCommand CreateFilteredClosure(Dictionary<Test, ManagedTestCommand> commands,
Test test, FilterSet<ITestDescriptor> filterSet, bool exactFilter, bool hasExplicitAncestor, ITestContextManager contextManager)
{
FilterSetResult filterSetResult = filterSet.Evaluate(test);
if (filterSetResult == FilterSetResult.Exclude)
return null;
bool isMatch = filterSetResult == FilterSetResult.Include;
bool isExplicit = isMatch && ! hasExplicitAncestor;
bool hasExplicitChild = false;
var children = new List<ManagedTestCommand>(test.Children.Count);
foreach (Test child in test.Children)
{
ManagedTestCommand childMonitor = CreateFilteredClosure(commands, child, filterSet, exactFilter,
hasExplicitAncestor || isExplicit, contextManager);
if (childMonitor != null)
{
children.Add(childMonitor);
if (childMonitor.IsExplicit)
hasExplicitChild = true;
}
}
if (isMatch || children.Count != 0 || (! exactFilter && hasExplicitAncestor))
return CreateCommand(commands, test, children, isExplicit || hasExplicitChild, contextManager);
return null;
}
/// <summary>
/// Creates a new Binding
/// </summary>
/// <param name="xmlnode">The XmlNode this Binding is defined in</param>
public Binding(XmlNode xmlnode)
{
string btype = xmlnode.Attributes["type"].Value;
string nm = xmlnode.SelectSingleNode("Name").InnerText;
XmlNode tnode = xmlnode.SelectSingleNode("Target");
string ttype = tnode.Attributes["type"].Value;
string tval = tnode.InnerText;
this.Enabled = xmlnode.Attributes["enabled"].Value == "1";
this.Name = nm;
switch (btype.ToUpper())
{
case "GRAPHICS": this.BindingType = BindingType.GRAPHICS; break;
case "PALETTE": this.BindingType = BindingType.PALETTE; break;
default: MainWindow.ShowError("Invalid Binding: " + nm + " has an invalid value for BindingType: " + btype); return;
}
this.Target = tval;
switch (ttype.ToUpper())
{
case "METHOD": this.TargetType = TargetType.METHOD; break;
case "LUA": this.TargetType = TargetType.LUA; break;
default: MainWindow.ShowError("Invalid Binding: " + nm + " has an invalid value for TargetType: " + ttype); return;
}
XmlNode fsetnode = xmlnode.SelectSingleNode("FilterSet");
if (fsetnode == null)
{
MainWindow.ShowError("Invalid Binding: " + nm + " does not have a FilterSet.");
return;
}
this.filterSet = new FilterSet(fsetnode);
this.IsValid = true;
}
public void RunFinished_is_fired_when_running_tests()
{
var progressMonitor = MockProgressMonitor.Instance;
var filter = new FilterSet<ITestDescriptor>(new NoneFilter<ITestDescriptor>());
filterService.Stub(fs => fs.GenerateFilterSetFromSelectedTests()).Return(filter);
optionsController.Stub(oc => oc.TestRunnerExtensions).Return(new BindingList<string>(new List<string>()));
StubTestRunnerFactory();
testController.Run(false, progressMonitor, new List<string>());
eventAggregator.AssertWasCalled(ea => ea.Send(Arg.Is(testController), Arg<RunFinished>.Is.Anything));
}
public void Duplicate_TestRunnerExtensions_are_only_added_once()
{
var progressMonitor = MockProgressMonitor.Instance;
var filter = new FilterSet<ITestDescriptor>(new NoneFilter<ITestDescriptor>());
filterService.Stub(ttm => ttm.GenerateFilterSetFromSelectedTests()).Return(filter);
var testRunnerExtensions = new BindingList<string>(new List<string>());
optionsController.Stub(oc => oc.TestRunnerExtensions).Return(testRunnerExtensions);
StubTestRunnerFactory();
testController.Run(false, progressMonitor, new List<string>(new[] { "DebugExtension, Gallio",
"DebugExtension, Gallio" }));
testRunner.AssertWasCalled(tr => tr.RegisterExtension(Arg<DebugExtension>.Is.Anything));
}
public void Dispose()
{
if (tool != null)
tool.Dispose();
this.tool = null;
this.filterSet.Dispose();
this.filterSet = null;
}
/// <summary>
/// Creates a default set of test execution options.
/// </summary>
public TestExecutionOptions()
{
filterSet = FilterSet<ITestDescriptor>.Empty;
properties = new PropertySet();
}
public string BuildQuery( params IFilterRule[] filters )
{
FilterSet fs = new FilterSet(FilterJoinOperator.And);
fs.Rules.AddRange( filters );
return FilterString( fs );
}
public void Filter_sets_should_be_applied_appropriately()
{
var root = new TestDataNode(new TestData("root", "root", "root"));
var test1 = new TestDataNode(new TestData("test1", "test1", "test1"));
var test2 = new TestDataNode(new TestData("test2", "test2", "test2"));
root.Nodes.Add(test1);
root.Nodes.Add(test2);
testTreeModel.Stub(ttm => ttm.Root).Return(root);
var filterSet = new FilterSet<ITestDescriptor>(new OrFilter<ITestDescriptor>(new[]
{
new IdFilter<ITestDescriptor>(new EqualityFilter<string>("test2"))
}));
filterService.ApplyFilterSet(filterSet);
Assert.AreEqual(CheckState.Indeterminate, root.CheckState);
Assert.AreEqual(CheckState.Unchecked, test1.CheckState);
Assert.AreEqual(CheckState.Checked, test2.CheckState);
}
public virtual string FilterString( FilterInfo fi )
{
object oVal = fi.Value;
string v = serializeValueForSearch( fi.Value );
if( fi.Operation == FilterOperation.Equals && oVal == null ||
fi.Operation == FilterOperation.DoesNotEqual && oVal == null )
{
throw new NotImplementedException("Cannot filter for null in DefaultSearchFilterFormatter");
}
else if( fi.Operation == FilterOperation.Contains || fi.Operation == FilterOperation.NotContains )
{
v = v + "*";
}
else if( fi.Operation == FilterOperation.NotContains )
{
}
else if( fi.Operation == FilterOperation.In )
{
if( oVal is IRecordList )
{
IRecordList irl = (IRecordList)oVal;
FilterSet inSet = new FilterSet(FilterJoinOperator.Or);
foreach( IRecord r in irl )
{
inSet.Rules.Add( new FilterInfo(fi.ColumnName, r.Id ) );
}
v = string.Format("({0})", FilterString(inSet) );
}
else if( oVal is IList )
{
IList il = (IList)oVal;
FilterSet inSet = new FilterSet(FilterJoinOperator.Or);
foreach( object o in il )
{
inSet.Rules.Add( new FilterInfo(fi.ColumnName, o ) );
}
v = string.Format("({0})", FilterString(inSet) );
}
}
else if (fi.Operation == FilterOperation.GreaterThan)
{
return String.Format("{0}:[{1} TO *]", fi.ColumnName, v);
}
else if (fi.Operation == FilterOperation.GreaterThanOrEqual)
{
return String.Format("{0}:{{{1} TO *}}", fi.ColumnName, v);
}
else if (fi.Operation == FilterOperation.LessThan)
{
return String.Format("{0}:[* TO {1}]", fi.ColumnName, v);
}
else if (fi.Operation == FilterOperation.LessThanOrEqual)
{
return String.Format("{0}:{{* TO {1}}}", fi.ColumnName, v);
}
else if (fi.Operation == FilterOperation.Equals)
{
return string.Format("{0}:{1}", fi.ColumnName, v);
}
else if (fi.Operation != FilterOperation.Equals)
{
throw new NotImplementedException("Operation " + fi.Operation + " not in DefaultSearchFilterFormatter");
}
return string.Format("{0}:{2}", fi.ColumnName, FilterInfo.FilterOperationToString(fi.Operation), v);
}
private FacadeTaskResult RunTests()
{
var logger = new FacadeLoggerWrapper(facadeLogger);
var runner = TestRunnerUtils.CreateTestRunnerByName(StandardTestRunnerFactoryNames.IsolatedAppDomain);
// Set parameters.
var testPackage = new TestPackage();
foreach (var assemblyLocation in assemblyLocations)
testPackage.AddFile(new FileInfo(assemblyLocation));
testPackage.ShadowCopy = facadeTaskExecutorConfiguration.ShadowCopy;
if (facadeTaskExecutorConfiguration.AssemblyFolder != null)
{
testPackage.ApplicationBaseDirectory = new DirectoryInfo(facadeTaskExecutorConfiguration.AssemblyFolder);
testPackage.WorkingDirectory = new DirectoryInfo(facadeTaskExecutorConfiguration.AssemblyFolder);
}
var testRunnerOptions = new TestRunnerOptions();
var testExplorationOptions = new TestExplorationOptions();
var filters = GenericCollectionUtils.ConvertAllToArray<string, Filter<string>>(explicitTestIds,
testId => new EqualityFilter<string>(testId));
var filterSet = new FilterSet<ITestDescriptor>(new IdFilter<ITestDescriptor>(new OrFilter<string>(filters)));
var testExecutionOptions = new TestExecutionOptions { FilterSet = filterSet };
// Install the listeners.
runner.Events.TestStepStarted += TestStepStarted;
runner.Events.TestStepFinished += TestStepFinished;
runner.Events.TestStepLifecyclePhaseChanged += TestStepLifecyclePhaseChanged;
// Run the tests.
try
{
try
{
runner.Initialize(testRunnerOptions, logger, CreateProgressMonitor());
Report report = runner.Run(testPackage, testExplorationOptions, testExecutionOptions, CreateProgressMonitor());
if (sessionId != null)
SessionCache.SaveSerializedReport(sessionId, report);
return FacadeTaskResult.Success;
}
catch (Exception ex)
{
if (sessionId != null)
SessionCache.ClearSerializedReport(sessionId);
logger.Log(LogSeverity.Error, "A fatal exception occurred during test execution.", ex);
return FacadeTaskResult.Exception;
}
finally
{
SubmitFailureForRemainingPendingTasks();
}
}
finally
{
runner.Dispose(CreateProgressMonitor());
}
}
