public void TestExtractorEventTransformer()
{
//testing on remote cache
INamedCache cache = CacheFactory.GetCache(CacheName);
cache.Clear();
Hashtable ht = new Hashtable();
Address address1 = new Address("Street1", "City1", "State1", "Zip1");
Address address2 = new Address("Street2", "City2", "State2", "Zip2");
ht.Add("key1", address1);
ht.Add("key2", address2);
cache.InsertAll(ht);
SyncListener listener = new SyncListener();
IFilter filter = new ValueChangeEventFilter("getStreet");
IValueExtractor extractor = IdentityExtractor.Instance;
ICacheEventTransformer transformer = new ExtractorEventTransformer(null, extractor);
cache.AddCacheListener(listener,
new CacheEventTransformerFilter(filter,
transformer),
false);
Assert.IsNull(listener.CacheEvent);
cache["key1"] = new Address("Street1", "City1a", "State1a", "Zip1a");
Assert.IsNull(listener.CacheEvent);
cache["key1"] = new Address("Street1a", "City1a", "State1a", "Zip1a");
Assert.IsNotNull(listener.CacheEvent);
CacheFactory.Shutdown();
}
/// <summary>
/// Parse the property name and initialize necessary extractor and
/// updater.
/// </summary>
protected internal void Init()
{
// allow composite property name (not documented)
string name = m_name;
int ofLast = name.LastIndexOf('.');
string prop = name.Substring(ofLast + 1);
IValueExtractor extractor = new ReflectionExtractor(prop); //(m_useIs ? "is" : "get") +
IValueUpdater updater = new ReflectionUpdater(prop); //"set" +
if (ofLast > 0)
{
string[] array = name.Substring(0, ofLast).Split(new char[] {'.'});
int count = array.Length;
IValueExtractor[] veGet = new IValueExtractor[count + 1];
IValueExtractor[] vePut = new IValueExtractor[count];
for (int i = 0; i < count; i++)
{
veGet[i] = vePut[i] = new ReflectionExtractor(array[i]); //"get" +
}
veGet[count] = extractor;
extractor = new ChainedExtractor(veGet);
updater = new CompositeUpdater(count == 1 ? vePut[0] : new ChainedExtractor(vePut),
updater);
}
m_extractor = extractor;
m_updater = updater;
}
internal ObjectValidator(
IValueExtractor valueExtractor,
Dictionary<Type, ValidationUnitCollection> ruleMap)
: base(valueExtractor)
{
mValueExtractor = valueExtractor;
mRuleMap = ruleMap;
}
internal ObjectValidator(
IValueExtractor valueExtractor,
Dictionary <Type, ValidationUnitCollection> ruleMap)
: base(valueExtractor)
{
mValueExtractor = valueExtractor;
mRuleMap = ruleMap;
}
/// <summary>
/// Determine a hash value for the <b>ExtractorEventTransformer</b>
/// object according to the general <b>Object.GetHashCode</b>
/// contract.
/// </summary>
/// <returns>
/// An integer hash value for this object.
/// </returns>
public override int GetHashCode()
{
IValueExtractor extractorOld = m_extractorOld;
IValueExtractor extractorNew = m_extractorNew;
return((extractorOld == null ? 0 : extractorOld.GetHashCode()) +
(extractorNew == null ? 0 : extractorNew.GetHashCode()));
}
public void TestWithEmptyString()
{
IValueExtractor ive = MockUtils.CreateExtractor(repository, "");
var rv = new RequiredValidator(ive, "");
Assert.IsFalse(rv.Validate(null), "Requried Validator does not recognize \"\" as null");
repository.VerifyAll();
}
public void TestNullValueInteger()
{
IValueExtractor ive = MockUtils.CreateExtractor(repository, 1);
var rv = new RequiredValidator(ive, 1);
Assert.IsFalse(rv.Validate(null), "Requried Validator does not recognize default value to be null");
repository.VerifyAll();
}
public void TestNullValue()
{
IValueExtractor ive = MockUtils.CreateExtractor(repository, null);
var rv = new RequiredValidator(ive, null);
Assert.IsFalse(rv.Validate(null), "Requried Validator does not check null");
repository.VerifyAll();
}
public void TestNotNullValue()
{
IValueExtractor ive = MockUtils.CreateExtractor(repository, new object());
var rv = new RequiredValidator(ive, null);
Assert.IsTrue(rv.Validate(null), "Requried Validator does not check object difference from null");
repository.VerifyAll();
}
/// <summary>
/// Apply the test to an <see cref="ICacheEntry"/>.
/// </summary>
/// <param name="entry">
/// The <b>ICacheEntry</b> to evaluate; never <c>null</c>.
/// </param>
/// <returns>
/// <b>true</b> if the test passes, <b>false</b> otherwise.
/// </returns>
public new virtual bool EvaluateEntry(ICacheEntry entry)
{
IValueExtractor extractor = ValueExtractor;
return(EvaluateExtracted(entry is IQueryCacheEntry
? ((IQueryCacheEntry)entry).Extract(extractor)
: InvocableCacheHelper.ExtractFromEntry(extractor, entry)));
}
/// <summary>
/// Extract value, it extract the part of the object specified by mPartName
/// and work on the type of the object passed in the first call.
/// </summary>
/// <param name="objToValidate"></param>
/// <returns></returns>
public object ExtractValue(object objToValidate)
{
if (innerValueExtractor == null)
{
innerValueExtractor = CreateInnerExtractor(objToValidate.GetType());
}
return(innerValueExtractor.ExtractValue(objToValidate));
}
public void TestNullWithEmptyString()
{
IValueExtractor ive = MockUtils.CreateExtractor(repository, null);
var rv = new RequiredValidator(ive, "");
Assert.IsFalse(rv.Validate(null), "Requried Validator does not check for null when has a default value");
repository.VerifyAll();
}
/// <summary>
/// Construct a GroupAggregator based on a specified
/// <see cref="IValueExtractor"/> and underlying
/// <see cref="IEntryAggregator"/>.
/// </summary>
/// <param name="extractor">
/// An <b>IValueExtractor</b> object that is used to split
/// <see cref="IInvocableCache"/> entries into
/// non-intersecting subsets; may not be <c>null</c>.
/// </param>
/// <param name="aggregator">
/// An <b>IEntryAggregator</b> object; may not be <c>null</c>.
/// </param>
/// <param name="filter">
/// An optional <see cref="IFilter"/> object used to filter out
/// results of individual group aggregation results.
/// </param>
protected GroupAggregator(IValueExtractor extractor, IEntryAggregator aggregator, IFilter filter)
{
Debug.Assert(extractor != null && aggregator != null);
m_extractor = extractor;
m_aggregator = aggregator;
m_filter = filter;
}
public SolutionEndRebuildSucceededEntry(IEntry entry, IValueExtractor valueExtractor, IDataService dataService)
{
this.entry = entry;
this.valueExtractor = valueExtractor;
this.dataService = dataService;
this.entry = entry;
this.valueExtractor = valueExtractor;
this.dataService = dataService;
}
public RangeValueValidator(
IValueExtractor valueExtractor,
Double minValue,
Double maxValue)
: base(valueExtractor)
{
mMinValue = minValue;
mMaxValue = maxValue;
}
public BinaryOperatorValueExtractor(
IValueExtractor left,
IValueExtractor right,
MathOperation operation)
{
mLeft = left;
mRight = right;
mOperation = operation;
}
/// <summary>
/// Create a validation unit to validate recursively an object, remember that an object
/// validation unit is not recursive.
/// </summary>
/// <param name="valueExtractor"></param>
/// <param name="partName"></param>
/// <param name="ruleMap"></param>
/// <returns></returns>
public static ValidationUnit CreateObjectValidationUnit(
IValueExtractor valueExtractor,
String partName,
Dictionary <Type, ValidationUnitCollection> ruleMap)
{
return(new MultipleValidatorValidationUnit(
false, new ErrorMessage("Field " + partName + " does not validate"),
new ObjectValidator(valueExtractor, ruleMap)));
}
public RangeValueValidator(
IValueExtractor valueExtractor,
Double minValue,
Double maxValue)
: base(valueExtractor)
{
mMinValue = minValue;
mMaxValue = maxValue;
}
public void TestBasicRangeTooLow()
{
var newObject = new object();
IValueExtractor ive = MockUtils.CreateExtractorForBasicRange(repository, -10.0f);
var rv = new RangeValueValidator(ive, 0, 100);
Assert.IsFalse(rv.Validate(newObject), "Range incorrect validation");
repository.VerifyAll();
}
public void TestBasicRangeGood()
{
var newObject = new object();
IValueExtractor ive = MockUtils.CreateExtractor(repository, 3.5d);
var rv = new RangeValueValidator(ive, 0, 100);
Assert.IsTrue(rv.Validate(newObject), "Range incorrect validation");
repository.VerifyAll();
}
public void TestValueExtractorCorrectlyCalled()
{
var newObject = new object();
IValueExtractor ive = MockUtils.CreateExtractor(repository, null, newObject);
var rv = new RequiredValidator(ive, null);
Assert.IsFalse(rv.Validate(newObject), "Requried Validator does not check null");
repository.VerifyAll();
}
public BinaryOperatorValueExtractor(
IValueExtractor left,
IValueExtractor right,
MathOperation operation)
{
mLeft = left;
mRight = right;
mOperation = operation;
}
/// <summary>
/// Add an index to the given dictionary of indexes, keyed by the given
/// extractor. Also add the index as a listener to the given cache.
/// </summary>
/// <param name="extractor">
/// The IValueExtractor object that is used to extract an indexable
/// property value from a cache entry.
/// </param>
/// <param name="ordered">
/// True if the contents of the indexed information should be ordered;
/// false otherwise
/// </param>
/// <param name="comparator">
/// The IComparer object which imposes an ordering on entries in the
/// indexed cache or <c>null</c> if the entries' values natural
/// ordering should be used.
/// </param>
/// <param name="cache">
/// The cache that the newly created ICacheIndex will use for
/// initialization and listen to for changes.
/// </param>
/// <param name="dictIndex">
/// The dictionary of indexes that the newly created ICacheIndex will
/// be added to.
/// </param>
public static void AddIndex(IValueExtractor extractor, bool ordered,
IComparer comparator, IObservableCache cache, IDictionary dictIndex)
{
var index = (ICacheIndex)dictIndex[extractor];
if (index == null)
{
for (int cAttempts = 4; ;)
{
if (extractor is IIndexAwareExtractor)
{
index = ((IIndexAwareExtractor)extractor).
CreateIndex(ordered, comparator, dictIndex);
if (index == null)
{
return;
}
}
else
{
index = new SimpleCacheIndex(extractor, ordered, comparator);
dictIndex[extractor] = index;
}
ICacheListener listener = EnsureListener(index);
cache.AddCacheListener(listener, null, false);
try
{
// build the index
foreach (ICacheEntry entry in cache)
{
index.Insert(entry);
}
break;
}
catch (InvalidOperationException ioe) //collection was modified
{
cache.RemoveCacheListener(listener);
if (--cAttempts == 0)
{
RemoveIndex(extractor, cache, dictIndex);
CacheFactory.Log("Exception occured during index rebuild: " +
ioe, CacheFactory.LogLevel.Error);
throw;
}
}
}
}
else if (!(ordered == index.IsOrdered &&
Equals(comparator, index.Comparer)))
{
throw new InvalidOperationException("Index for " + extractor +
" already exists;" +
" remove the index and add it with the new settings");
}
}
public void TestValueThatIsNotAString()
{
IValueExtractor ive = MockRepository.GenerateStub <IValueExtractor>();
ive.Expect(o => o.ExtractValue(null)).Return(new Object());
ive.Expect(o => o.SourceName).Return("property");
var rv = new RangeLengthValidator(ive, 1, 10);
Assert.Throws(typeof(ArgumentException), () => rv.Validate(null));
}
public void TestNullString()
{
IValueExtractor ive = MockRepository.GenerateStub <IValueExtractor>();
ive.Expect(o => o.ExtractValue(null)).Return(null);
ive.Expect(o => o.SourceName).Return("property");
var rv = new RangeLengthValidator(ive, 1, 10);
Assert.IsFalse(rv.Validate(null));
}
/// <summary>
/// Construct a ConditionalIndex.
/// </summary>
/// <param name="filter">the filter that is used to evaluate the
/// entries of the resource cache that is being indexed.
/// </param>
/// <param name="extractor">
/// the <see cref="IValueExtractor"/> that is used to extract an
/// indexed value from a resource cache entry.
/// </param>
/// <param name="ordered">
/// <c>true</c> iff the contents of the indexed information should be
/// ordered; <c>false</c> otherwise.
/// </param>
/// <param name="comparer">
/// the IComparer object which imposes an ordering on entries in the
/// index; or <tt>null</tt> if the entries' values natural ordering
/// should be used.
/// </param>
/// <param name="forwardIndex">
/// specifies whether or not this index supports a forward map
/// </param>
public ConditionalIndex(IFilter filter, IValueExtractor extractor,
bool ordered, IComparer comparer, bool forwardIndex)
: base(extractor, ordered, comparer, false)
{
Filter = filter;
IsForwardIndexSupported = forwardIndex;
m_partial = false;
Initialize(forwardIndex);
}
public void TestBasicValidationGood()
{
var newObject = new object();
IValueExtractor ive = MockRepository.GenerateStub <IValueExtractor>();
ive.Stub(obj => obj.ExtractValue(null)).IgnoreArguments().Return(20);
var rv = new ActionValidation <Int32>(ive, num => num > 10);
Assert.IsTrue(rv.Validate(newObject), "Range incorrect validation");
}
/// <summary>
/// Construct the ConditionalExtractor.
/// </summary>
/// <param name="filter">
/// The filter used by this extractor to create a
/// <see cref="ConditionalIndex"/>; must not be null.
/// </param>
/// <param name="extractor">
/// The extractor used by this extractor to create a
/// <see cref="ConditionalIndex"/>; the created index will be
/// associated with this extractor in the given index map; must
/// not be null.
/// </param>
/// <param name="forwardIndex">
/// Specifies whether or not this extractor will create a
/// <see cref="ConditionalIndex"/> that supports a forward index.
/// </param>
public ConditionalExtractor(IFilter filter, IValueExtractor extractor,
bool forwardIndex)
{
Debug.Assert(filter != null && extractor != null,
"Filter and extractor must not be null");
Filter = filter;
Extractor = extractor;
IsForwardIndexSupported = forwardIndex;
}
/// <summary>
/// Create an instance of GroupAggregator based on a specified member
/// name(s), an <see cref="IEntryAggregator"/> and a result
/// evaluation filter.
/// </summary>
/// <remarks>
/// If the specified underlying aggregator is an instance of
/// <see cref="IParallelAwareAggregator"/>, then a parallel-aware
/// instance of the GroupAggregator will be created. Otherwise, the
/// resulting GroupAggregator will not be parallel-aware and could be
/// ill-suited for aggregations run against large partitioned caches.
/// </remarks>
/// <param name="member">
/// A member name or a comma-delimited sequence of names that results
/// in a <see cref="ReflectionExtractor"/> or a
/// <see cref="MultiExtractor"/> that will be used to split
/// <see cref="IInvocableCache"/> entries into distinct groups.
/// </param>
/// <param name="aggregator">
/// An underlying <b>IEntryAggregator</b>.
/// </param>
/// <param name="filter">
/// An optional <b>IFilter</b> object that will be used to evaluate
/// results of each individual group aggregation.
/// </param>
/// <returns>
/// An instance of GroupAggregator based on a specified member
/// name(s), an <see cref="IEntryAggregator"/> and a result
/// evaluation filter.
/// </returns>
public static GroupAggregator CreateInstance(string member, IEntryAggregator aggregator, IFilter filter)
{
IValueExtractor extractor = member.IndexOf(',') >= 0
? new MultiExtractor(member)
: member.IndexOf('.') >= 0
? new ChainedExtractor(member)
: (IValueExtractor) new ReflectionExtractor(member);
return(CreateInstance(extractor, aggregator, filter));
}
public void TestBasicValidationGood()
{
IValueExtractor ive = MockRepository.GenerateStub <IValueExtractor>();
ive.Expect(m => m.SourceName).Return("Property");
ive.Expect(m => m.ExtractValue(null))
.IgnoreArguments().Return("Testregexgood");
var rv = new RegexValidator(ive, "Test.*good");
Assert.That((Boolean)rv.Validate(null), Is.True);
}
private static ConditionalIndex createIndex(IDictionary map, IFilter filter, IValueExtractor extractor, bool fSupportForwardMap)
{
var index = new ConditionalIndex(filter, extractor, false, null, fSupportForwardMap);
foreach (DictionaryEntry de in map)
{
ICacheEntry entry = new CacheEntry(de.Key, de.Value);
index.Insert(entry);
}
return(index);
}
public void TestNullValueExtractor()
{
IValueExtractor nullValueExtractor = NullImplementation.GetValueExtractor();
Assert.IsNotNull(nullValueExtractor);
Assert.IsInstanceOf(typeof(NullImplementation.NullValueExtractor), nullValueExtractor);
object o = new object();
object o1 = nullValueExtractor.Extract(o);
Assert.AreEqual(o, o1);
}
public void TestValidString()
{
IValueExtractor ive = MockRepository.GenerateStub <IValueExtractor>();
ive.Expect(o => o.ExtractValue(null)).Return("String OK");
ive.Expect(o => o.SourceName).Return("property");
var rv = new RangeLengthValidator(ive, 1, 10);
SingleValidationResult res = rv.Validate(null);
Assert.IsTrue(res);
}
/// <summary>
/// Given an array of object of validation attributes create all
/// requested ValidationUnits.
/// </summary>
/// <param name="vc"></param>
///<param name="valueExtractor">The value extractor proposed by the caller
/// the real value extractor can be overriden by the attribute.</param>
/// <param name="validationfields"></param>
private static void BuildValidationUnitFromAttributeList(
ValidationUnitCollection vc,
IValueExtractor valueExtractor,
object[] validationfields)
{
foreach (BaseValidationAttribute va in validationfields)
{
if (va.IsValueExtractorOverriden)
valueExtractor = va.CreateValueExtractor();
vc.Add( ValidationUnit.CreateValidationUnit(
va.CreateErrorMessage(),
va.CreateValidator(valueExtractor)));
}
}
public RequiredValidator(IValueExtractor valueExtractor)
: this(valueExtractor, null)
{
}
public override IValidator CreateValidator(IValueExtractor valueExtractor)
{
return new ConstantResultValidator(mResult);
}
/// <summary> /// this is the real routine that is overriden by derived classes /// </summary> /// <param name="valueExtractor"></param> /// <returns></returns> public abstract IValidator CreateValidator(IValueExtractor valueExtractor);
public NotEmptyValidator(IValueExtractor valueExtractor)
: base(valueExtractor)
{
}
public override IValidator CreateValidator(IValueExtractor valueExtractor)
{
return new RangeValueValidator(valueExtractor, mMinValue, mMaxValue) ;
}
public RangeLengthValidator(IValueExtractor valueExtractor, int minLenght, int maxLength)
: base(valueExtractor)
{
MinLenght = minLenght;
MaxLength = maxLength;
}
public RequiredValidator(IValueExtractor valueExtractor, object nullValue)
: base(valueExtractor)
{
mNullValue = nullValue;
}
public override IValidator CreateValidator(IValueExtractor valueExtractor)
{
throw new NotImplementedException();
}
public RangeLengthValidator(IValueExtractor valueExtractor, int maxLength)
: this(valueExtractor, 0, maxLength)
{
}
/// <summary>
/// Create a validation unit to validate recursively an object, remember that an object
/// validation unit is not recursive.
/// </summary>
/// <param name="valueExtractor"></param>
/// <param name="partName"></param>
/// <param name="ruleMap"></param>
/// <returns></returns>
public static ValidationUnit CreateObjectValidationUnit(
IValueExtractor valueExtractor,
String partName,
Dictionary<Type, ValidationUnitCollection> ruleMap)
{
return new MultipleValidatorValidationUnit(
false, new ErrorMessage("Field " + partName + " does not validate"),
new ObjectValidator(valueExtractor, ruleMap));
}
public override IValidator CreateValidator(IValueExtractor valueExtractor)
{
return new RequiredValidator(valueExtractor, mNullValue);
}
/// <summary>
/// Extract value, it extract the part of the object specified by mPartName
/// and work on the type of the object passed in the first call.
/// </summary>
/// <param name="objToValidate"></param>
/// <returns></returns>
public object ExtractValue(object objToValidate)
{
if (innerValueExtractor == null)
innerValueExtractor = CreateInnerExtractor(objToValidate.GetType());
return innerValueExtractor.ExtractValue(objToValidate);
}
NullableValidator(IValueExtractor valueExtractor)
: base(valueExtractor)
{
}
public RegexValidator(IValueExtractor valueExtractor, String regexExpression)
: base(valueExtractor)
{
this.RegexExpression = regexExpression;
}
