public static IEnumerable <object[]> GreaterOrEqualTo_Should_CollectError_Data()
{
return(RulesHelper.GetSetsCompilation(
NumberDataHelper.GreaterOrEqualTo_Unsigned(_convert),
NumberDataHelper.GreaterOrEqualTo_Signed(_convert),
NumberDataHelper.GreaterOrEqualTo_Limits(short.MinValue, short.MaxValue, 1)
));
}
public static IEnumerable <object[]> Between_Should_CollectError_Data()
{
return(RulesHelper.GetSetsCompilation(
NumberDataHelper.Between_Unsigned(_convert),
NumberDataHelper.Between_Signed(_convert),
NumberDataHelper.Between_Limits(long.MinValue, long.MaxValue, 1)
));
}
public static IEnumerable <object[]> NonPositive_Should_CollectError_Data()
{
return(RulesHelper.GetTestDataCombined(
NumbersTestData.NonPositive_Unsigned(Convert),
NumbersTestData.NonPositive_Signed(Convert),
new[] { new object[] { 0.000001F, false } },
new[] { new object[] { -0.000001F, true } }));
}
public static IEnumerable <object[]> GreaterThan_Should_CollectError_Data()
{
return(RulesHelper.GetSetsCompilation(
NumberDataHelper.GreaterThan_Unsigned(_convert),
NumberDataHelper.GreaterThan_Signed(_convert),
NumberDataHelper.GreaterThan_Limits(decimal.MinValue, decimal.MaxValue, 1)
));
}
public void ToQualityProfile_WhenRuleSetNull_ReturnsNull()
{
// Arrange & Act
var result = RulesHelper.ToQualityProfile(null, Language.Unknown);
// Assert
result.Should().BeNull();
}
private void SetDataSource()
{
var rulesDtos = RulesHelper.GetRulesDtos();
var bindingSource = new BindingSource();
bindingSource.DataSource = rulesDtos;
dataGridView1.DataSource = bindingSource;
}
public void ToRuleSet_WhenRoslynExportProfileResponseNull_ReturnsNull()
{
// Arrange & Act
var result = RulesHelper.ToRuleSet(null);
// Assert
result.Should().BeNull();
}
public static IEnumerable <object[]> Between_Should_CollectError_Data()
{
return(RulesHelper.GetTestDataCombined(
NumbersTestData.Between_Unsigned(Convert),
NumbersTestData.Between_Signed(Convert),
NumbersTestData.Between_Limits(float.MinValue, float.MaxValue, 0),
new[] { new object[] { 0.999999F, 1, 1.000001F, true } },
new[] { new object[] { 0.999999F, 0.999999F, 1.000001F, false } },
new[] { new object[] { 0.999999F, 1.000001F, 1.000001F, false } }));
}
private void Window_Closed(object sender, EventArgs e)
{
if (App.RulesTreeView != null)
{
App.RulesTreeView.PromptChangesNotSaved();
}
RulesHelper.DeleteWorkingTempFile();
App.Current.Shutdown();
}
public static IEnumerable <object[]> NotEqualTo_Should_CollectError_Data()
{
return(RulesHelper.GetTestDataCombined(
NumbersTestData.NotEqualTo_Unsigned(Convert),
NumbersTestData.NotEqualTo_Signed(Convert),
NumbersTestData.NotEqualTo_Limits(double.MinValue, double.MaxValue, 0),
new[] { new object[] { 0.999999D, 0D, true } },
new[] { new object[] { 1.000001D, 0D, true } },
new[] { new object[] { 1.123456D, 1.123456D, false } }));
}
public void InitialState_TestingValidatedCommand_SuccessResultReplied()
{
var aggregateId = TestAggregateId.New;
var commandId = SourceId.New;
var command = new ValidatedCommand(aggregateId, true).WithSourceId(commandId);
var result = RulesHelper.ProcessRules(command);
result.Should().NotBeNull().And.Match <ValidationResult>(r => r.IsValid);
}
public static IEnumerable <object[]> Between_Should_CollectError_Data()
{
return(RulesHelper.GetSetsCompilation(
NumberDataHelper.Between_Signed(_convert),
NumberDataHelper.Between_Unsigned(_convert),
NumberDataHelper.Between_Limits(double.MinValue, double.MaxValue, 0),
new[] { new object[] { 0.999999d, 1, 1.000001d, true } },
new[] { new object[] { 0.999999d, 0.999999d, 1.000001d, false } },
new[] { new object[] { 0.999999d, 1.000001d, 1.000001d, false } }
));
}
public static IEnumerable <object[]> NotCloseTo_MemberData()
{
return(RulesHelper.GetSetsCompilation(
NumberDataHelper.NotEqualTo_Signed(_convert),
NumberDataHelper.NotEqualTo_Unsigned(_convert),
NumberDataHelper.NotEqualTo_Limits(double.MinValue, double.MaxValue, 0),
new[] { new object[] { 0.999999d, 0d, true } },
new[] { new object[] { 1.000001d, 0d, true } },
new[] { new object[] { 1.123456d, 1.123456d, false } }
));
}
public Map Solve(Map map)
{
var cell = map.Cells[0][0];
var dfsStack = new Stack <CellMapPair>();
dfsStack.Push(new CellMapPair(cell, map));
while (dfsStack.Any())
{
var cellMapPair = dfsStack.Pop();
var currentMap = cellMapPair.Map;
var currentCell = cellMapPair.Cell;
if (currentCell.IsSolved)
{
if (currentCell.IsLastCell)
{
return(currentMap);
}
var nextCoordinate = currentCell.Coordinate.GetNextCoordinate();
dfsStack.Push(new CellMapPair(currentMap.Cells[nextCoordinate.Row][nextCoordinate.Column], currentMap));
continue;
}
var candidates = currentCell.Candidates.Any() ? currentCell.Candidates : new List <int> {
1, 2, 3, 4, 5, 6, 7, 8, 9
};
foreach (var candidate in candidates)
{
if (RulesHelper.ViolatesRules(candidate, currentMap, currentCell))
{
continue;
}
var candidateMap = currentMap.Clone();
var candidateCell = currentCell.Clone();
candidateCell.Number = candidate;
candidateMap.Cells[candidateCell.Coordinate.Row][candidateCell.Coordinate.Column] = candidateCell;
if (currentCell.IsLastCell)
{
return(candidateMap);
}
var nextCoordinate = currentCell.Coordinate.GetNextCoordinate();
dfsStack.Push(new CellMapPair(candidateMap.Cells[nextCoordinate.Row][nextCoordinate.Column], candidateMap));
//Console.Clear();
//Console.WriteLine(candidateMap);
//Thread.Sleep(50);
}
}
return(map);
}
public void ToRuleSet_DumpsContentToRuleSetFileAndLoadsIt()
{
// Arrange
var ruleset = TestRuleSetHelper.CreateTestRuleSet(numRules: 10);
var roslynProfileExporter = RoslynExportProfileHelper.CreateExport(ruleset);
// Act
var result = RulesHelper.ToRuleSet(roslynProfileExporter);
// Assert
TestRuleSetHelper.RuleSetToXml(result).Should().Be(TestRuleSetHelper.RuleSetToXml(ruleset));
}
public static IEnumerable <object[]> NonZero_WithTolerance_Should_CollectError_MemberData()
{
return(RulesHelper.GetTestDataCombined(
new[] { new object[] { 0.000100F, 0.0000001F, true } },
new[] { new object[] { 0.000100F, 0.000001F, true } },
new[] { new object[] { 0.000100F, 0.00001F, true } },
new[] { new object[] { 0.000100F, 0.0001F, true } },
new[] { new object[] { 0.000100F, 0.001F, false } },
new[] { new object[] { 0.000100F, 0.01F, false } },
new[] { new object[] { 0.000100F, 0.1F, false } },
new[] { new object[] { 0.000100F, 1F, false } }));
}
public static IEnumerable <object[]> EqualTo_WithTolerance_Should_CollectError_MemberData()
{
return(RulesHelper.GetTestDataCombined(
new[] { new object[] { 1.000100D, 1.000199D, 0.0000001D, false } },
new[] { new object[] { 1.000100D, 1.000199D, 0.000001D, false } },
new[] { new object[] { 1.000100D, 1.000199D, 0.00001D, false } },
new[] { new object[] { 1.000100D, 1.000199D, 0.0001D, true } },
new[] { new object[] { 1.000100D, 1.000199D, 0.001D, true } },
new[] { new object[] { 1.000100D, 1.000199D, 0.01D, true } },
new[] { new object[] { 1.000100D, 1.000199D, 0.1D, true } },
new[] { new object[] { 1.000100D, 1.000199D, 1D, true } }));
}
public RulesTreeView()
{
InitializeComponent();
RulesHelper.CreateWorkableTempFile();
_tracker.DataChanged += new RulesChangeTracker.DataChangeHandler(_tracker_DataChanged);
RulesHelper.DataCommitted += new RulesHelper.ChangesCommittedHandler(_tracker_DataCommitted);
InitTreeData();
treeRules.ContextMenu = treeRules.Resources["NodeContext"] as System.Windows.Controls.ContextMenu;
}
public void ToQualityProfile_SelectRulesNotMarkedAsNone()
{
// Arrange
var ruleset = TestRuleSetHelper.CreateTestRuleSet(numRules: 5);
var nonNoneRulesCount = ruleset.Rules.Count(x => x.Action != RuleAction.None);
// Act
var result = RulesHelper.ToQualityProfile(ruleset, Language.CSharp);
// Assert
result.Language.Should().Be(Language.CSharp);
result.Rules.Should().HaveCount(nonNoneRulesCount);
}
public static IEnumerable <object[]> NotCloseTo_WithTolerance_MemberData()
{
return(RulesHelper.GetSetsCompilation(
new[] { new object[] { 1.000100d, 1.000199d, 0.0000001d, true } },
new[] { new object[] { 1.000100d, 1.000199d, 0.000001d, true } },
new[] { new object[] { 1.000100d, 1.000199d, 0.00001d, true } },
new[] { new object[] { 1.000100d, 1.000199d, 0.0001d, false } },
new[] { new object[] { 1.000100d, 1.000199d, 0.001d, false } },
new[] { new object[] { 1.000100d, 1.000199d, 0.01d, false } },
new[] { new object[] { 1.000100d, 1.000199d, 0.1d, false } },
new[] { new object[] { 1.000100d, 1.000199d, 1d, false } }
));
}
public string Apply(int i)
{
var message = string.Empty;
foreach (var fooBarQix in RulesHelper.GetFooBarQixKeys())
{
if (i % fooBarQix == 0)
{
message += RulesHelper.GetFooBarQix(fooBarQix);
}
}
return(message);
}
private void InitTreeData()
{
this.treeRules.DataContext = null;
_rootNode = new ObservableCollection <RootNode>();
_rootNode.Add(
new RootNode
{
Name = "Business Rules"
});
_rootNode[0].Nodes = RulesHelper.GetRulesHierarchy();
this.treeRules.DataContext = _rootNode;
}
private void Refresh()
{
List <BusinessRuleComponentVO> list = RulesHelper.GetComponentList();
if (_isSelection)
{
//Only show parent components.
list = (from l in list
where l.ParentId == Guid.Empty
select l).ToList();
}
lvComponents.ItemsSource = list;
}
/// <summary>
/// Saves the tracking changes.
/// </summary>
/// <returns>Succesful save or not.</returns>
public bool SaveChangesToWorkingFile()
{
try
{
RulesHelper.SaveRules(_changedRules != null ? _changedRules.ToList() : null,
_changedComponents != null? _changedComponents.ToList() : null);
this.ClearChanges();
}
catch (Exception ex)
{
MessageBox.Show("Error trying to save: " + ex.Message
+ Environment.NewLine + "Stack trace: " + ex.StackTrace);
return(false);
}
return(true);
}
public override void OnBindViewHolder(RecyclerView.ViewHolder holder, int position)
{
ViewHolderExpandableRule vh = holder as ViewHolderExpandableRule;
vh.IsRecyclable = false;
vh.ExpandableLayout.SetInRecyclerView(true);
vh.Name.Text = ruleSet[position].Name;
bool isSubCategory = RulesHelper.HasTwoSubLevels(ruleSet[position].ChildRules);
if (isSubCategory)
{
vh.Icon.SetImageResource(Resource.Drawable.arrow_expand);
SetUpInnerRecyclerView(vh.InnerRecyclerView, ruleSet[position].ChildRules);
}
else
{
vh.Icon.SetImageResource(Resource.Drawable.arrow_advance);
}
if (vh.ClickHandler != null)
{
vh.View.Click -= vh.ClickHandler;
}
vh.ClickHandler = new EventHandler((sender, e) => {
if (isSubCategory)
{
if (vh.ExpandableLayout.Expanded)
{
vh.Icon.SetImageResource(Resource.Drawable.arrow_expand);
}
else
{
vh.Icon.SetImageResource(Resource.Drawable.arrow_collapse);
}
vh.ExpandableLayout.Toggle();
}
else
{
var activity = parent.Activity as MainActivity;
activity.LoadRulesSubsectionsFragment(ruleSet[position]);
}
});
vh.View.Click += vh.ClickHandler;
}
private List <int> FindCandidates(Map map, Cell cell)
{
var possibleCandidates = cell.Candidates.Any() ? cell.Candidates : new List <int> {
1, 2, 3, 4, 5, 6, 7, 8, 9
};
var candidates = new List <int>();
foreach (var candidate in possibleCandidates)
{
if (RulesHelper.ViolatesRules(candidate, map, cell))
{
continue;
}
candidates.Add(candidate);
}
return(candidates);
}
protected override void OnCreate(Bundle savedInstanceState)
{
SetContentView(Resource.Layout.activity_main);
SupportToolbar toolbar = FindViewById <SupportToolbar>(Resource.Id.mainToolbar);
SetSupportActionBar(toolbar);
SupportActionBar.SetHomeAsUpIndicator(Resource.Drawable.ic_menu);
SupportActionBar.SetDisplayHomeAsUpEnabled(true);
_drawerLayout = FindViewById <DrawerLayout>(Resource.Id.drawer_layout);
_navigationView = FindViewById <NavigationView>(Resource.Id.nav_view);
if (_navigationView != null)
{
SetupDrawerContent(_navigationView);
}
var projectName = savedInstanceState?.GetString("projectName");
var previousMenuItem = savedInstanceState?.GetInt("menuItem");
if (projectName != null)
{
CurrentProject = ProjectsLogic.DownloadProjects().Find(p => p.Name == projectName);
CurrentProject.ProjectRules = RulesHelper.DownloadRules(Assets);
ActivateProjectSubmenu(CurrentProject);
}
if (previousMenuItem != null && _navigationView != null)
{
_previousMenuItem = _navigationView.Menu.FindItem((int)previousMenuItem);
_previousMenuItem.SetChecked(true);
}
_searchQuery = savedInstanceState?.GetString("searchQuery") ?? string.Empty;
base.OnCreate(savedInstanceState);
if (savedInstanceState == null)
{
LoadProjectsListFragment();
}
}
public string Apply(int i)
{
var message = string.Empty;
foreach (var numberChar in i.ToString())
{
foreach (var fooBarQix in RulesHelper.GetFooBarQixKeys())
{
if (numberChar.Equals(fooBarQix.ToString()[0]))
{
message += RulesHelper.GetFooBarQix(fooBarQix);
}
}
if (numberChar.Equals('0'))
{
message += "*";
}
}
return(message);
}
private void button2_Click(object sender, EventArgs e)
{
var rulesDtos = RulesHelper.GetRulesDtos();
var rulesForExport = string.Empty;
foreach (var rulesDto in rulesDtos)
{
var csvLine = string.Empty;
csvLine += rulesDto.FindWhat + ",";
csvLine += rulesDto.ReplaceWith + ",";
csvLine += rulesDto.FileName + ",";
csvLine += rulesDto.ProjectName + ",";
csvLine += rulesDto.SolutionName + ",";
csvLine += rulesDto.Enabled + ",";
csvLine += rulesDto.CaseSensitive + ",";
csvLine += rulesDto.Comments + Environment.NewLine;
rulesForExport += csvLine;
}
ExportRules(rulesForExport);
}
/// <summary>
/// Begin site method - call prior to getParameters
/// </summary>
/// <param name="caller">Calling class object</param>
/// <param name="siteId">SiteId specifier object</param>
/// <param name="ruleIds">List of Business rule strings</param>
/// <param name="rules">List of BusinessRuleVO objects - Output param</param>
/// <returns>PawnRulesSystemReturnCode</returns>
public PawnRulesSystemReturnCode beginSite(object caller, SiteId siteId, List <string> ruleIds, out Dictionary <string, BusinessRuleVO> rules)
{
rules = new Dictionary <string, BusinessRuleVO>();
//Validate input
if (caller == null || CollectionUtilities.isEmpty(ruleIds))
{
return
(new PawnRulesSystemReturnCode(
PawnRulesSystemReturnCode.Code.ERROR,
"Input values to beginSite are invalid."));
}
//Check if this object is already using the pawn rules system
if (this.beginBlockRegistry.ContainsKey(caller))
{
PairType <SiteId, bool> curSiteBegin = this.beginBlockRegistry[caller];
if (curSiteBegin.Right)
{
return
(new PawnRulesSystemReturnCode(
PawnRulesSystemReturnCode.Code.WARNING,
"Already in an active begin block for this site and this caller parent object."));
}
curSiteBegin.Right = true;
curSiteBegin.Left = siteId;
}
else
{
this.beginBlockRegistry.Add(caller, new PairType <SiteId, bool>(siteId, true));
}
//Set site id
this.currentSite = siteId;
//Change last parameter to true if you want to save the rules file to the disk after it is loaded
//into the rules engine data structure
//rules = RulesHelper.BuildBusinessRules(siteId, true);
rules = RulesHelper.BuildBusinessRules(siteId);
return(new PawnRulesSystemReturnCode(PawnRulesSystemReturnCode.Code.SUCCESS));
}