static void TestAddTag(string expr, string tag, string expectedParenthesizedResultExpr)
{
var p = TagsPredicate.Parse(expr);
p = p.Add(tag);
Assert.AreEqual(expectedParenthesizedResultExpr, p.ToString('p'), $"'{expr}' + '{tag}' must be '{expectedParenthesizedResultExpr}'");
}
static void TestUsedTags(string expr, params string[] expectedTags)
{
var p = TagsPredicate.Parse(expr);
var actual = p.UsedTags.Select(tag => tag.Item1).ToHashSet();
Assert.AreEqual(true, actual.SetEquals(expectedTags), $"{expr} must have used tags ${string.Join(",", expectedTags)}");
}
static void TestMatch(string expr, bool expectMatch, params string[] tags)
{
var p = TagsPredicate.Parse(expr);
var isMatch = p.IsMatch(new HashSet <string>(tags));
Assert.AreEqual(expectMatch, isMatch, $"{expr} matches [${string.Join(" ", tags)}]?, expected ${expectMatch}");
}
public PresenterPersistentState(
Persistence.IStorageManager storageManager,
string globalStateStorageEntryName,
string logSourceSpecificStateSectionName,
IChangeNotification changeNotification,
Func <ImmutableHashSet <string> > availableTagsSelector,
Func <IEnumerable <ILogSource> > sourcesSelector
)
{
this.changeNotification = changeNotification;
this.stateEntry = storageManager.GetEntry(globalStateStorageEntryName);
this.logSourceStateSectionName = logSourceSpecificStateSectionName;
this.availableTagsSelector = CreateAvailableTagsSelectorAdapter(availableTagsSelector);
this.sourcesSelector = sourcesSelector;
this.getDefaultPredicate = Selectors.Create(
this.availableTagsSelector,
availableTags => TagsPredicate.MakeMatchAnyPredicate(availableTags)
);
this.getTagsPredicate = Selectors.Create(
getDefaultPredicate,
sourcesSelector,
() => savedTagsRevision,
(defaultPredicate, sources, _revision) => LoadPredicate(sources, defaultPredicate, logSourceStateSectionName)
);
}
static void TestParse(string str, string parenthesizedExpr, string parentheseslessExpr, string error = null)
{
try
{
var p = TagsPredicate.Parse(str);
Assert.AreEqual(parenthesizedExpr, p.ToString('p'));
Assert.AreEqual(parentheseslessExpr, p.ToString());
}
catch (TagsPredicate.SyntaxError e)
{
Assert.AreEqual(error, $"{e.Message} at {e.Position}");
}
}
public void BeforeEach()
{
model = Substitute.For <IPostprocessorTags>();
view = Substitute.For <IView>();
dialogView = Substitute.For <IDialogView>();
alerts = Substitute.For <IAlertPopup>();
view.When(v => v.SetViewModel(Arg.Any <IViewModel>())).Do(x => viewModel = x.Arg <IViewModel>());
view.CreateDialog(Arg.Do <IDialogViewModel>(x => dialogViewModel = x), Arg.Any <IEnumerable <string> >(), Arg.Any <string>()).Returns(dialogView);
changeNotification = Substitute.For <IChangeNotification>();
model.AvailableTags.Returns(ImmutableHashSet.Create(new[] { "foo", "bar", "item-1", "item-2", "abd", "abc" }));
model.TagsPredicate.Returns(TagsPredicate.Parse("bar OR item-1 AND NOT abc"));
presenter = new TagsListPresenter(
model,
view,
changeNotification,
alerts
);
}
static bool RecognizeKeyword(Token token, out string keyword)
{
return(TagsPredicate.ParseKeyword(token.value, out keyword));
}
static void TestCombine(string expectedResultExpr, params string[] inputExprs)
{
var p = TagsPredicate.Combine(inputExprs.Select(TagsPredicate.Parse));
Assert.AreEqual(expectedResultExpr, p.ToString(), $"combination of '{string.Join(" ", inputExprs)}' must be '{expectedResultExpr}'");
}
