public void TestEqualsFilter()
{
EqualsFilter v1 = new EqualsFilter(ConnectorAttributeBuilder.Build("foo", "bar"));
EqualsFilter v2 = (EqualsFilter)CloneObject(v1);
Assert.AreEqual(v1.GetAttribute(), v2.GetAttribute());
}
protected override String CreateEqualsExpression(EqualsFilter filter, Boolean not)
{
// Note: The LDAP equality filter matches any one attribute value,
// whereas the connector EqualsFilter matches an attribute and
// its values exactly.
return(CreateContainsAllValuesExpressionInternal(filter, not));
}
public Dictionary <string, object> VisitEqualsFilter(Hashtable p, EqualsFilter filter)
{
var values = filter.GetAttribute().Value;
if (values.Count == 1)
{
return(CreateMap("EQUALS", filter.GetAttribute().Name, values[0]));
}
throw new NotImplementedException("Equality visitor does not implement multi value attribute");
}
public void TestComparisonValueExtractor()
{
// testing on remote cache
INamedCache cache = CacheFactory.GetCache(CacheName);
cache.Clear();
Score score = new Score(1, 1, 126, 10000L, 1.24f, 1432.55, new decimal(11223344), new RawInt128(new byte[] { 1 }), 1);
cache.Insert("score1", score);
IValueExtractor exByte = new ReflectionExtractor("getByteValue");
IValueExtractor exShort = new ReflectionExtractor("getShortValue");
IValueExtractor exInt = new ReflectionExtractor("getIntValue");
IValueExtractor exLong = new ReflectionExtractor("getLongValue");
IValueExtractor exFloat = new ReflectionExtractor("getFloatValue");
IValueExtractor exDouble = new ReflectionExtractor("getDoubleValue");
IValueExtractor exDecimal = new ReflectionExtractor("getBigDecimalValue");
IValueExtractor exInt128 = new ReflectionExtractor("getBigIntegerValue");
//different ways to instantiate same extractor
ComparisonValueExtractor cve1 = new ComparisonValueExtractor(exByte, exShort);
ComparisonValueExtractor cve2 = new ComparisonValueExtractor(exInt, exLong);
ComparisonValueExtractor cve3 = new ComparisonValueExtractor(exFloat, exDouble);
ComparisonValueExtractor cve4 = new ComparisonValueExtractor(exDecimal, exDecimal);
ComparisonValueExtractor cve5 = new ComparisonValueExtractor(exInt128, exInt128);
IFilter filter = new EqualsFilter(cve1, score.ByteValue - score.ShortValue);
ICollection keys = cache.GetKeys(filter);
Assert.IsNotEmpty(keys);
Assert.IsTrue(keys.Count == 1);
filter = new EqualsFilter(cve2, score.IntValue - score.LongValue);
keys = cache.GetKeys(filter);
Assert.IsNotEmpty(keys);
Assert.IsTrue(keys.Count == 1);
filter = new EqualsFilter(cve3, score.FloatValue - score.DoubleValue);
keys = cache.GetKeys(filter);
Assert.IsNotEmpty(keys);
Assert.IsTrue(keys.Count == 1);
filter = new EqualsFilter(cve4, (decimal)0);
keys = cache.GetKeys(filter);
Assert.IsNotEmpty(keys);
Assert.IsTrue(keys.Count == 1);
filter = new EqualsFilter(cve5, NumberUtils.DecimalToRawInt128(score.RawInt128Value.ToDecimal() - score.RawInt128Value.ToDecimal()));
keys = cache.GetKeys(filter);
Assert.IsNotEmpty(keys);
Assert.IsTrue(keys.Count == 1);
CacheFactory.Shutdown();
}
protected override string CreateEqualsExpression(EqualsFilter filter, bool not)
{
ConnectorAttribute attr = filter.GetAttribute();
if (attr.Name.Equals(Name.NAME))
{
return("Name:" + attr.Value.First().ToString());
}
return(null);
}
public void TestViewBuilderWithFilter()
{
IFilter filter = new EqualsFilter("foo", "bar");
INamedCache cache = new ViewBuilder(GetCache("v-filter")).Filter(filter).Build();
Assert.IsInstanceOf(typeof(ContinuousQueryCache), cache);
ContinuousQueryCache queryCache = (ContinuousQueryCache)cache;
Assert.That(queryCache.Filter, Is.EqualTo(filter));
}
public void ConverterQueryCacheTests()
{
IQueryCache cache = InstantiateCache();
IConverter cDown = new ConvertDown();
IConverter cUp = new ConvertUp();
IQueryCache convCache = ConverterCollections.GetQueryCache(cache, cUp, cDown, cUp, cDown);
Assert.IsNotNull(convCache);
for (int i = 0; i < 5; i++)
{
convCache.Add(i, i + 1);
}
Assert.AreEqual(convCache.Count, 5);
IFilter filter = new EqualsFilter(IdentityExtractor.Instance, cDown.Convert("4"));
object[] keys = convCache.GetKeys(filter);
Assert.IsNotNull(keys);
Assert.AreEqual(keys.Length, 1);
Assert.AreEqual(keys[0], "3");
filter = new GreaterEqualsFilter(IdentityExtractor.Instance, "2");
object[] values = convCache.GetValues(filter);
Assert.IsNotNull(values);
Assert.AreEqual(values.Length, 4);
values = convCache.GetValues(filter, Comparer.DefaultInvariant);
Assert.IsNotNull(values);
Assert.AreEqual(values.Length, 4);
Assert.AreEqual(values[0], "2");
object[] entries = convCache.GetEntries(filter);
Assert.IsNotNull(entries);
Assert.AreEqual(entries.Length, 4);
entries = convCache.GetEntries(filter, new KeyExtractor(IdentityExtractor.Instance));
Assert.IsNotNull(entries);
Assert.AreEqual(entries.Length, 4);
Assert.IsInstanceOf(typeof(ICacheEntry), entries[0]);
ICacheEntry e = entries[0] as ICacheEntry;
Assert.IsNotNull(e);
Assert.AreEqual(e.Key, "1");
Assert.AreEqual(e.Value, "2");
Assert.IsInstanceOf(typeof(ConverterCollections.ConverterQueryCache), convCache);
ConverterCollections.ConverterQueryCache cqc = convCache as ConverterCollections.ConverterQueryCache;
Assert.IsNotNull(cqc);
Assert.AreEqual(cqc.QueryCache, cache);
}
public void TestIdentityExtractor()
{
IValueExtractor extractor = IdentityExtractor.Instance;
IValueExtractor extractor1 = IdentityExtractor.Instance;
Assert.IsNotNull(extractor);
Assert.AreEqual(extractor, extractor1);
Assert.AreEqual(extractor.ToString(), extractor1.ToString());
Assert.AreEqual(extractor.GetHashCode(), extractor1.GetHashCode());
object o = new DictionaryEntry("key", "value");
object o1 = extractor.Extract(o);
Assert.AreEqual(o, o1);
IdentityExtractor ie = extractor as IdentityExtractor;
Assert.AreEqual(ie.Compare("ana", "cikic"), -1);
TestQueryCacheEntry entry1 = new TestQueryCacheEntry("1", 1);
TestQueryCacheEntry entry2 = new TestQueryCacheEntry("2", 2);
Assert.AreEqual(ie.CompareEntries(entry2, entry1), 1);
//testing on remote cache
INamedCache cache = CacheFactory.GetCache(CacheName);
cache.Clear();
Hashtable ht = new Hashtable();
ht.Add("identityExtractorKey1", 435);
ht.Add("identityExtractorKey2", 253);
ht.Add("identityExtractorKey3", 3);
ht.Add("identityExtractorKey4", null);
ht.Add("identityExtractorKey5", -3);
cache.InsertAll(ht);
IFilter filter = new EqualsFilter(extractor, 253);
ICollection keys = cache.GetKeys(filter);
Assert.Contains("identityExtractorKey2", (IList)keys);
Assert.AreEqual(keys.Count, 1);
CacheFactory.Shutdown();
}
/// <summary>
///
/// </summary>
/// <param name="p"></param>
/// <param name="filter"></param>
/// <exception cref="NotImplementedException"></exception>
/// <returns></returns>
public string VisitEqualsFilter(Hashtable p, EqualsFilter filter)
{
var name = filter.GetAttribute().Name;
var name2 = name as String;
if (p.ContainsKey(name))
{
name2 = p[name] as String;
}
var values = filter.GetAttribute().Value;
if (values.Count == 1)
{
return(string.Format("{0} -eq \"{1}\"", name2, values[0]));
}
throw new NotImplementedException("Equality visitor does not implement multi value attributes");
}
public void testCoh5516()
{
IFilter typeFilter = new EqualsFilter("getType", "bird");
IValueExtractor intExtractor = new ReflectionExtractor("getWings");
var condExtractor = new ConditionalExtractor(typeFilter, intExtractor, false);
IDictionary map = new HashDictionary();
var index = condExtractor.CreateIndex(false, null, map);
var bird = new Bird();
var fish = new Fish();
var entry1 = new CacheEntry(0, bird, bird);
var entry2 = new CacheEntry(1, fish, fish);
// add entries of type Fish and Bird - only the Bird should get indexed
index.Insert(entry1);
index.Insert(entry2);
// remove entries of type Fish and Bird - only the Bird should get indexed
index.Delete(entry1);
index.Delete(entry2);
}
protected override String CreateEqualsExpression(EqualsFilter filter, Boolean not)
{
// The LDAP equality filter matches any one attribute value,
// whereas the connector EqualsFilter matches an attribute and
// its values exactly.
if (not)
{
return(null);
}
ConnectorAttribute attr = filter.GetAttribute();
// if there is only one thing to search on, and it's
// a uid we need to convert the uid to something we
// can search on. NOTE: only handling the case where
// we are doing an equality search, and only one item
// is in the equality search ... It's all that makes
// sense for uid.
if (attr is Uid)
{
String attrValue = ((Uid)attr).GetUidValue();
if (LooksLikeGUID(attrValue))
{
String searchGuid = GetUidSearchString(((Uid)attr).GetUidValue());
attr = new Uid(searchGuid);
}
else
{
attr = new Name(attrValue);
}
}
String[] attrNames = GetLdapNamesForAttribute(attr);
if (attrNames == null)
{
return(null);
}
StringBuilder builder = new StringBuilder();
if (attr.Value == null)
{
return(null);
}
if (attr.Value.Count == 1)
{
BuildEqualityFilter(builder, attrNames,
attr.Value[0]);
}
else
{
builder.Append("(&");
foreach (Object value in attr.Value)
{
BuildEqualityFilter(builder, attrNames, value);
}
builder.Append(')');
}
return(builder.ToString());
}
public void TestEqualsFilter()
{
EqualsFilter v1 = new EqualsFilter(ConnectorAttributeBuilder.Build("foo", "bar"));
EqualsFilter v2 = (EqualsFilter)CloneObject(v1);
Assert.AreEqual(v1.GetAttribute(), v2.GetAttribute());
}
protected override String CreateEqualsExpression(EqualsFilter filter, bool not)
{
String rv = "( = " + filter.GetAttribute().Name + " [" + filter.GetAttribute().Value[0] + "] )";
return(Not(rv, not));
}
protected override Filter CreateEqualsExpression(EqualsFilter filter, bool not)
{
return(not ? FilterBuilder.Not(filter) : filter);
}
protected override String CreateEqualsExpression(EqualsFilter filter, Boolean not)
{
return(CreateContainsAllValuesExpressionInternal(filter, not));
}
protected override IDictionary <String, Object> CreateEqualsExpression(EqualsFilter filter, Boolean not)
{
return(CreateFilter("EQUALS", filter, not));
}
public void TestKeyExtractor()
{
IValueExtractor extractor = new KeyExtractor((IValueExtractor)null);
IValueExtractor extractor1 = new KeyExtractor((IValueExtractor)null);
IValueExtractor extractor2 = IdentityExtractor.Instance;
Assert.IsNotNull(extractor);
Assert.AreEqual(extractor, extractor1);
Assert.AreNotEqual(extractor, extractor2);
Assert.AreEqual(extractor.ToString(), extractor1.ToString());
Assert.AreEqual(extractor.GetHashCode(), extractor1.GetHashCode());
extractor = new KeyExtractor(IdentityExtractor.Instance);
Assert.IsNotNull(extractor);
IValueExtractor innerExtractor = (extractor as KeyExtractor).Extractor;
Assert.IsNotNull(innerExtractor);
Assert.IsInstanceOf(typeof(IdentityExtractor), innerExtractor);
object o = "value";
Assert.AreEqual(o, extractor.Extract(o));
extractor = new KeyExtractor("field");
Assert.IsNotNull(extractor);
innerExtractor = (extractor as KeyExtractor).Extractor;
Assert.IsNotNull(innerExtractor);
Assert.IsInstanceOf(typeof(ReflectionExtractor), innerExtractor);
ReflectionExtractor re = innerExtractor as ReflectionExtractor;
Assert.AreEqual(re.MemberName, "field");
o = new ReflectionTestType();
Assert.AreEqual(extractor.Extract(o), (o as ReflectionTestType).field);
extractor = new KeyExtractor("InnerMember.field");
Assert.IsNotNull(extractor);
innerExtractor = (extractor as KeyExtractor).Extractor;
Assert.IsNotNull(innerExtractor);
Assert.IsInstanceOf(typeof(ChainedExtractor), innerExtractor);
ChainedExtractor ce = innerExtractor as ChainedExtractor;
Assert.IsNotNull(ce.Extractors);
Assert.AreEqual(ce.Extractors.Length, 2);
Assert.AreEqual(extractor.Extract(o), (o as ReflectionTestType).InnerMember.field);
// testing on remote cache
INamedCache cache = CacheFactory.GetCache(CacheName);
cache.Clear();
Hashtable ht = new Hashtable();
ht.Add("identityExtractorKey1", 435);
ht.Add("identityExtractorKey2", 253);
ht.Add("identityExtractorKey3", 3);
ht.Add("identityExtractorKey4", null);
ht.Add("identityExtractorKey5", -3);
cache.InsertAll(ht);
extractor = new KeyExtractor(IdentityExtractor.Instance);
IFilter filter = new EqualsFilter(extractor, "identityExtractorKey3");
ICollection keys = cache.GetKeys(filter);
Assert.Contains("identityExtractorKey3", (IList)keys);
Assert.AreEqual(keys.Count, 1);
CacheFactory.Shutdown();
}
private void UpdatePropertiesPanel(XmlNode selectedItem)
{
if (selectedItem.Name == "input")
{
switch (selectedItem.Attributes["type"].Value)
{
case "MSMQ":
MyGrid = new MSMQIN(selectedItem, this.View);
break;
case "MQ":
MyGrid = new MQIN(selectedItem, this.View);
break;
case "FILE":
MyGrid = new FILEIN(selectedItem, this.View);
break;
case "KAFKA":
MyGrid = new KAFKAIN(selectedItem, this.View);
break;
case "HTTP":
MyGrid = new HTTPIN(selectedItem, this.View);
break;
case "RABBITDEFEX":
MyGrid = new RABBITIN(selectedItem, this.View);
break;
case "MQTT":
MyGrid = new MQTTIN(selectedItem, this.View);
break;
case "TCPSERVER":
MyGrid = new TCPIN(selectedItem, this.View);
break;
case "TESTSOURCE":
MyGrid = new TESTSOURCE(selectedItem, this.View);
break;
}
}
else if (selectedItem.Name == "output" || selectedItem.Name == "altqueue")
{
switch (selectedItem.Attributes["type"].Value)
{
case "MSMQ":
MyGrid = new MSMQOUT(selectedItem, this.View);
break;
case "MQ":
MyGrid = new MQOUT(selectedItem, this.View);
break;
case "FILE":
MyGrid = new FILEOUT(selectedItem, this.View);
break;
case "KAFKA":
MyGrid = new KAFKAOUT(selectedItem, this.View);
break;
case "REST":
MyGrid = new RESTOUT(selectedItem, this.View);
break;
case "HTTP":
MyGrid = new HTTPOUT(selectedItem, this.View);
break;
case "TCPCLIENT":
MyGrid = new TCPOUT(selectedItem, this.View);
break;
case "RABBITDEFEX":
MyGrid = new RABBITOUT(selectedItem, this.View);
break;
case "MQTT":
MyGrid = new MQTTIN(selectedItem, this.View);
break;
case "SMTP":
MyGrid = new SMTPOut(selectedItem, this.View);
break;
case "FTP":
MyGrid = new FTPOut(selectedItem, this.View);
break;
case "SINK":
MyGrid = new SINK(selectedItem, this.View);
break;
}
}
else if (selectedItem.Name == "monitor")
{
MyGrid = new MonitorGrid(selectedItem, this.View);
}
else if (selectedItem.Name == "filter")
{
MyGrid = new Filter(selectedItem, this.View);
}
else if (selectedItem.Name == "pipe")
{
MyGrid = new PIPE(selectedItem, this.View);
}
else if (selectedItem.Name == "namespace")
{
MyGrid = new NameSpaceGrid(selectedItem, this.View);
}
else if (selectedItem.Name == "service")
{
MyGrid = new ServiceSetting(selectedItem, this.View);
}
else if (selectedItem.Name == "and" || selectedItem.Name == "or" || selectedItem.Name == "xor" || selectedItem.Name == "not")
{
MyGrid = new BooleanExpression(selectedItem, this.View);
}
else if (selectedItem.Name == "contains")
{
MyGrid = new ContainsFilter(selectedItem, this.View);
}
else if (selectedItem.Name == "equals")
{
MyGrid = new EqualsFilter(selectedItem, this.View);
}
else if (selectedItem.Name == "matches")
{
MyGrid = new MatchesFilter(selectedItem, this.View);
}
else if (selectedItem.Name == "length")
{
MyGrid = new LengthFilter(selectedItem, this.View);
}
else if (selectedItem.Name == "xpexists")
{
MyGrid = new XPExistsFilter(selectedItem, this.View);
}
else if (selectedItem.Name == "xpmatches")
{
MyGrid = new XPMatchesFilter(selectedItem, this.View);
}
else if (selectedItem.Name == "xpequals")
{
MyGrid = new XPEqualsFilter(selectedItem, this.View);
}
else if (selectedItem.Name == "dateRange")
{
MyGrid = new DateRangeFilter(selectedItem, this.View);
}
else if (selectedItem.Name == "contextContains")
{
MyGrid = new ContextFilter(selectedItem, this.View);
}
OnPropertyChanged("MyGrid");
}
public void TestReflectionExtractor()
{
IValueExtractor extractor = new ReflectionExtractor("field");
IValueExtractor extractor1 = new ReflectionExtractor("field");
IValueExtractor extractor2 = IdentityExtractor.Instance;
Assert.IsNotNull(extractor);
Assert.AreEqual(extractor, extractor1);
Assert.AreNotEqual(extractor, extractor2);
Assert.AreEqual(extractor.ToString(), extractor1.ToString());
Assert.AreEqual(extractor.GetHashCode(), extractor1.GetHashCode());
ReflectionTestType o = new ReflectionTestType();
Assert.AreEqual(extractor.Extract(o), o.field);
extractor = new ReflectionExtractor("Property");
Assert.AreEqual(extractor.Extract(o), o.Property);
extractor = new ReflectionExtractor("GetMethod");
Assert.AreEqual(extractor.Extract(o), o.GetMethod());
Assert.IsNull(extractor.Extract(null));
try
{
extractor = new ReflectionExtractor("InvalidMember");
extractor.Extract(o);
}
catch (Exception e)
{
Assert.IsInstanceOf(typeof(ArgumentException), e.InnerException);
}
// testing on remote cache
INamedCache cache = CacheFactory.GetCache(CacheName);
cache.Clear();
Address a1 = new Address("street1", "city1", "state1", "zip1");
Address a2 = new Address("street2", "city2", "state2", "zip2");
Address a3 = new Address("street3", "city1", "state3", "zip3");
Hashtable ht = new Hashtable();
ht.Add("reflectionExtractorKey1", a1);
ht.Add("reflectionExtractorKey2", a2);
ht.Add("reflectionExtractorKey3", a3);
cache.InsertAll(ht);
extractor = new ReflectionExtractor("getCity");
IFilter filter = new EqualsFilter(extractor, "city1");
ICollection keys = cache.GetKeys(filter);
Assert.Contains("reflectionExtractorKey1", (IList)keys);
Assert.Contains("reflectionExtractorKey3", (IList)keys);
Assert.AreEqual(keys.Count, 2);
extractor = new ReflectionExtractor("Sum", new object[] { 10 });
o = new ReflectionTestType();
o.field = 10;
Assert.AreEqual(extractor.Extract(o), 20);
o.field = 4;
Assert.AreEqual(extractor.Extract(o), 14);
CacheFactory.Shutdown();
}
public string VisitEqualsFilter(Hashtable p, EqualsFilter filter)
{
throw new NotImplementedException();
}
public void TestChainedExtractor()
{
IValueExtractor extractor = new ChainedExtractor("InnerMember.field");
IValueExtractor re1 = new ReflectionExtractor("InnerMember");
IValueExtractor re2 = new ReflectionExtractor("field");
IValueExtractor[] res = { re1, re2 };
IValueExtractor extractor1 = new ChainedExtractor(re1, re2);
IValueExtractor extractor2 = new ChainedExtractor(res);
Assert.IsNotNull(extractor);
Assert.IsNotNull(extractor1);
Assert.IsNotNull(extractor2);
Assert.AreEqual(extractor, extractor1);
Assert.AreEqual(extractor1, extractor2);
Assert.AreEqual(extractor.ToString(), extractor1.ToString());
Assert.AreEqual(extractor.GetHashCode(), extractor1.GetHashCode());
IValueExtractor[] extractors = (extractor as ChainedExtractor).Extractors;
Assert.IsNotNull(extractors);
Assert.AreEqual(extractors.Length, 2);
Assert.AreEqual(extractors[0], re1);
Assert.AreEqual(extractors[1], re2);
ReflectionTestType o = new ReflectionTestType();
Assert.AreEqual(extractor.Extract(o), o.InnerMember.field);
Assert.AreEqual(extractor.Extract(o), extractors[1].Extract(extractors[0].Extract(o)));
Assert.IsNull(extractor.Extract(null));
// testing on remote cache
INamedCache cache = CacheFactory.GetCache(CacheName);
cache.Clear();
Address a1 = new Address("street1", "city1", "state1", "zip1");
Address a2 = new Address("street2", "city2", "state2", "zip2");
Address a3 = new Address("street3", "city1", "state3", "zip3");
Hashtable ht = new Hashtable();
ht.Add(a1, "chainedExtractorValue1");
ht.Add(a2, "chainedExtractorValue2");
ht.Add(a3, "chainedExtractorValue3");
cache.InsertAll(ht);
extractor1 = new KeyExtractor(IdentityExtractor.Instance);
extractor2 = new KeyExtractor(new ReflectionExtractor("getCity"));
extractor = new KeyExtractor(new ChainedExtractor(extractor1, extractor2));
IFilter filter = new EqualsFilter(extractor, "city1");
ICollection keys = cache.GetKeys(filter);
ArrayList list = new ArrayList(keys);
Assert.AreEqual(keys.Count, 2);
Assert.AreEqual(((Address)list[0]).City, "city1");
Assert.AreEqual(((Address)list[1]).City, "city1");
CacheFactory.Shutdown();
}
