public void CanonBinaryFilter()
{
var canon = new FilterCanonicalizer();
var tagFilter1 = new TagFilter(Tag("A"));
var tagFilter2 = new TagFilter(Tag("A"));
var negatingFilter1 = new NegatingFilter(new TagFilter(Tag("B")));
var negatingFilter2 = new NegatingFilter(new TagFilter(Tag("B")));
var binaryFilter1 = new BinaryFilter(tagFilter1, FilterOperator.And, negatingFilter1);
var binaryFilter2 = new BinaryFilter(tagFilter2, FilterOperator.And, negatingFilter2);
var binaryFilter3 = new BinaryFilter(negatingFilter1, FilterOperator.And, tagFilter2);
var binaryFilter4 = new BinaryFilter(tagFilter1, FilterOperator.Or, negatingFilter1);
var canonBinaryFilter1 = binaryFilter1.Canonicalize(canon);
var canonBinaryFilter2 = binaryFilter2.Canonicalize(canon);
var canonBinaryFilter3 = binaryFilter3.Canonicalize(canon);
var canonBinaryFilter4 = binaryFilter4.Canonicalize(canon);
Assert.Same(canonBinaryFilter1, canonBinaryFilter2);
Assert.Same(canonBinaryFilter1, canonBinaryFilter3);
Assert.NotSame(canonBinaryFilter1, canonBinaryFilter4);
var canonFilter1 = canonBinaryFilter1 as BinaryFilter;
var canonFilter2 = canonBinaryFilter2 as BinaryFilter;
var canonFilter3 = canonBinaryFilter3 as BinaryFilter;
Assert.NotNull(canonFilter1);
Assert.NotNull(canonFilter2);
Assert.NotNull(canonFilter3);
Assert.Same(canonFilter1.Left, canonFilter2.Left);
Assert.Same(canonFilter1.Right, canonFilter2.Right);
Assert.Same(canonFilter1.Left, canonFilter3.Left);
Assert.Same(canonFilter1.Right, canonFilter3.Right);
}
public void CanonManyFiltersReduce()
{
var canon = new FilterCanonicalizer();
int filterCount = 1000;
List <PipFilter> pipFilters = new List <PipFilter>();
List <StringId> modules = new List <StringId>();
List <StringId> tags = new List <StringId>();
var binaryFilterLeft = new BinaryFilter(new TagFilter(Tag("B")), FilterOperator.And, new TagFilter(Tag("C")));
pipFilters.Add(binaryFilterLeft);
for (int i = 0; i < filterCount; i++)
{
tags.Add(Tag(i.ToString()));
pipFilters.Add(new TagFilter(Tag(i.ToString())));
modules.Add(ModuleName(i.ToString()));
pipFilters.Add(new ModuleFilter(ModuleName(i.ToString())));
}
var random = new Random();
while (pipFilters.Count > 1)
{
var lastIndex = pipFilters.Count - 1;
var randomIndex = random.Next(0, lastIndex);
var randomFilter = pipFilters[randomIndex];
var lastFilter = pipFilters[lastIndex];
pipFilters[randomIndex] = new BinaryFilter(randomFilter, FilterOperator.Or, lastFilter);
pipFilters.RemoveAt(lastIndex);
}
var finalFilter = pipFilters[0];
var canonFilter = finalFilter.Canonicalize(canon);
BinaryFilter binaryFilter = (BinaryFilter)canonFilter;
var childFilters = new HashSet <PipFilter>(binaryFilter.TraverseBinaryChildFilters(bf => bf.FilterOperator == FilterOperator.Or)
.Where(pf => !(pf is BinaryFilter bf && bf.FilterOperator == FilterOperator.Or)));
var expectedFilters = new[]
{
binaryFilterLeft.Canonicalize(canon),
new MultiTagsOrFilter(tags.ToArray()).Canonicalize(canon),
new ModuleFilter(modules.ToArray()).Canonicalize(canon)
};
Assert.True(childFilters.SetEquals(expectedFilters));
}
public void CanonAndSimplifyBinaryFilter()
{
var canon = new FilterCanonicalizer();
var negatingFilter1 = new NegatingFilter(new TagFilter(Tag("B")));
var negatingFilter2 = new NegatingFilter(new TagFilter(Tag("B")));
var binaryFilter = new BinaryFilter(negatingFilter1, FilterOperator.And, negatingFilter2);
var canonFilter = binaryFilter.Canonicalize(canon);
Assert.Same(canonFilter, negatingFilter1.Canonicalize(canon));
}
public void CanonBinaryOrFilterPushTagToLeft()
{
var canon = new FilterCanonicalizer();
var tagFilter = new TagFilter(Tag("D"));
var binaryFilterLeft = new BinaryFilter(new TagFilter(Tag("B")), FilterOperator.And, new TagFilter(Tag("C")));
var binaryFilter = new BinaryFilter(binaryFilterLeft, FilterOperator.Or, tagFilter);
var canonFilter = binaryFilter.Canonicalize(canon);
var expected = new BinaryFilter(tagFilter, FilterOperator.Or, binaryFilterLeft).Canonicalize(canon);
Assert.Same(expected, canonFilter);
}
internal static QueryFilter ToBlobComparisonFilter(this ExpressionType expressionType, PropertyDefinition propertyDefinition, byte[] propertyValue)
{
BinaryFilter binaryFilter = new BinaryFilter(propertyDefinition, propertyValue, MatchOptions.ExactPhrase, MatchFlags.Default);
if (expressionType == ExpressionType.Equal)
{
return(binaryFilter);
}
if (expressionType != ExpressionType.NotEqual)
{
throw new UnsupportedExpressionException(Strings.UnsupportedOperatorWithNull(expressionType));
}
return(new NotFilter(binaryFilter));
}
public void CanonBinaryOrFilterToMultiTags()
{
var canon = new FilterCanonicalizer();
var tagFilter = new TagFilter(Tag("A"));
var multiTagsFilter = new MultiTagsOrFilter(Tag("B"), Tag("C"));
var binaryFilter = new BinaryFilter(tagFilter, FilterOperator.Or, multiTagsFilter);
var canonFilter = binaryFilter.Canonicalize(canon);
var expected = new MultiTagsOrFilter(Tag("A"), Tag("B"), Tag("C")).Canonicalize(canon);
Assert.Same(expected, canonFilter);
}
public void CanonBinaryOrFilterPushTagToLeftAndJoinAsMultiTags()
{
var canon = new FilterCanonicalizer();
var tagFilterA = new TagFilter(Tag("A"));
var tagFilterD = new TagFilter(Tag("D"));
var binaryFilterLeft = new BinaryFilter(new TagFilter(Tag("B")), FilterOperator.And, new TagFilter(Tag("C")));
var innerbinaryFilter = new BinaryFilter(binaryFilterLeft, FilterOperator.Or, tagFilterD);
var outerBinaryFilter = new BinaryFilter(tagFilterA, FilterOperator.Or, innerbinaryFilter);
var canonFilter = outerBinaryFilter.Canonicalize(canon);
var expected = new BinaryFilter(new MultiTagsOrFilter(Tag("A"), Tag("D")), FilterOperator.Or, binaryFilterLeft).Canonicalize(canon);
Assert.Same(expected, canonFilter);
}
/// <summary>
/// Creates filter from tags.
/// </summary>
protected RootFilter CreateFilterFromTags(string tag1, string tag2 = null)
{
PipFilter filter;
if (tag2 != null)
{
filter = new BinaryFilter(new TagFilter(StringId.Create(Context.PathTable.StringTable, tag1)),
FilterOperator.Or,
new TagFilter(StringId.Create(Context.PathTable.StringTable, tag2)));
}
else
{
filter = new TagFilter(StringId.Create(Context.PathTable.StringTable, tag1));
}
return(new RootFilter(filter));
}
internal ContentRestrictionData(StoreSession storeSession, ContentFilter contentFilter)
{
this.Flags = (int)base.GetContentFlags(contentFilter.MatchFlags, contentFilter.MatchOptions);
this.PropTag = base.GetPropTagFromDefinition(storeSession, contentFilter.Property);
this.MultiValued = ((PropTag)this.PropTag).IsMultiValued();
if (contentFilter is TextFilter)
{
TextFilter textFilter = (TextFilter)contentFilter;
this.Value = new PropValueData(((PropTag)this.PropTag).ChangePropType(PropType.String), textFilter.Text);
return;
}
if (contentFilter is BinaryFilter)
{
BinaryFilter binaryFilter = (BinaryFilter)contentFilter;
this.Value = new PropValueData(((PropTag)this.PropTag).ChangePropType(PropType.Binary), binaryFilter.BinaryData);
return;
}
MrsTracer.Common.Error("Unknown content filter type '{0}' in content restriction data constructor", new object[]
{
contentFilter.GetType()
});
throw new CorruptRestrictionDataException();
}
