// Initialize static fields that are sensitive to order of initialization.
// Most compilers would probably intialize these in lexical order but it
// may not be guaranteed in all cases so we do it directly.
static DelayedConstraintTests()
{
DelegateReturningValue = new ActualValueDelegate(MethodReturningValue);
DelegateReturningFalse = new ActualValueDelegate(MethodReturningFalse);
DelegateReturningZero = new ActualValueDelegate(MethodReturningZero);
SuccessDelegates = new ActualValueDelegate<object>[] { DelegateReturningValue };
FailureDelegates = new ActualValueDelegate<object>[] { DelegateReturningFalse, DelegateReturningZero };
}
/// <summary>
/// Test whether the constraint is satisfied by a delegate
/// </summary>
/// <param name="del">The delegate whose value is to be tested</param>
/// <returns>A ConstraintResult</returns>
public override ConstraintResult ApplyTo <TActual>(ActualValueDelegate <TActual> del)
{
long now = Stopwatch.GetTimestamp();
long delayEnd = TimestampOffset(now, DelayInterval.AsTimeSpan);
object actual;
if (PollingInterval.IsNotZero)
{
long nextPoll = TimestampOffset(now, PollingInterval.AsTimeSpan);
while ((now = Stopwatch.GetTimestamp()) < delayEnd)
{
if (nextPoll > now)
{
ThreadUtility.BlockingDelay((int)TimestampDiff(delayEnd < nextPoll ? delayEnd : nextPoll, now).TotalMilliseconds);
}
nextPoll = TimestampOffset(now, PollingInterval.AsTimeSpan);
actual = InvokeDelegate(del);
try
{
ConstraintResult result = BaseConstraint.ApplyTo(actual);
if (result.IsSuccess)
{
return(new ConstraintResult(this, actual, true));
}
}
catch (Exception)
{
// Ignore any exceptions when polling
}
}
}
if ((now = Stopwatch.GetTimestamp()) < delayEnd)
{
ThreadUtility.BlockingDelay((int)TimestampDiff(delayEnd, now).TotalMilliseconds);
}
actual = InvokeDelegate(del);
return(new ConstraintResult(this, actual, BaseConstraint.ApplyTo(actual).IsSuccess));
}
public void Delete_RemoveNewsWithDuplicatedId_ReturnInvalidOperationException()
{
// Arrange
var news = new News
{
Id = 0
};
Use <INewsRepository>()
.Setup(s => s.Query(It.IsAny <NewsSpecifications>()))
.Returns(new List <News> {
news, news
});
// Act
ActualValueDelegate <object> deleteDelegate = () => Sub.Delete(news.Id);
// Assert
Assert.That(deleteDelegate, Throws.TypeOf <InvalidOperationException>());
}
public void Test_CodableConcept_TokenIndexSetter_UnsupportedCodeType()
{
//Arrange
var CodeableConcept = new CodeableConcept();
CodeableConcept.Coding = new System.Collections.Generic.List <Coding>()
{
new Coding()
{
Code = "SomeCode", System = "SomeSystem"
}
};
TokenIndex Index = new TokenIndex();
//Act
ActualValueDelegate <TokenIndex> testDelegate = () => IndexSetterFactory.Create(typeof(TokenIndex)).Set(CodeableConcept, Index) as TokenIndex;
//Assert
Assert.That(testDelegate, Throws.TypeOf <Pyro.Common.BusinessEntities.Dto.DtoPyroException>());
}
public void TestNxNode()
{
var evaluator = new ConditionEvaluator();
var sut = new PermissionsService(new ConditionParser(), (new PermissionsScanner().All(typeof(Permissions))), evaluator);
ActualValueDelegate <bool> del = () =>
{
sut.InsertSerialized(new GrantStub
{
GrantType = GrantType.Allow,
Index = 1,
NodeKey = "Dog.Feed",
PermissionType = PermissionType.ResourceBound,
Identifier = 1,
PermissionChain = PermissionChainName
});
return(true);
};
Assert.That(del, Throws.TypeOf <ArgumentException>());
}
public void Test_Address_TokenIndexSetter_UnsupportedCodeType()
{
//Arrange
var TheCode = Hl7.Fhir.Model.Bundle.SearchEntryMode.Include;
string CodeString = TheCode.GetLiteral();
//string CodeString = Hl7.Fhir.Introspection.EnumMapping.Create(typeof(Hl7.Fhir.Model.Bundle.SearchEntryMode)).GetLiteral(TheCode);
var Code = new Code <Bundle.SearchEntryMode>();
Code.Value = TheCode;
TokenIndex Index = new TokenIndex();
//Act
ActualValueDelegate <TokenIndex> testDelegate = () => IndexSetterFactory.Create(typeof(TokenIndex)).Set(Code, Index) as TokenIndex;
//Act
Index = IndexSetterFactory.Create(typeof(TokenIndex)).Set(Code, Index) as TokenIndex;
//Assert
Assert.IsNull(Index);
}
/// <summary>
/// Test whether the constraint is satisfied by a delegate
/// </summary>
/// <param name="del">The delegate whose value is to be tested</param>
/// <returns>True for if the base constraint fails, false if it succeeds</returns>
public override bool Matches(ActualValueDelegate del)
{
int remainingDelay = delayInMilliseconds;
while (pollingInterval > 0 && pollingInterval < remainingDelay)
{
remainingDelay -= pollingInterval;
Thread.Sleep(pollingInterval);
this.actual = del();
if (baseConstraint.Matches(actual))
{
return(true);
}
}
if (remainingDelay > 0)
{
Thread.Sleep(remainingDelay);
}
this.actual = del();
return(baseConstraint.Matches(actual));
}
/// <summary>
/// Truncated Assert.That implementation throwing no exceptions on failure
/// </summary>
/// <typeparam name="TActual"></typeparam>
/// <param name="actual"></param>
/// <param name="expression"></param>
/// <param name="timeout">Overrides RequestTimeout</param>
/// <returns>whether the test passed</returns>
private static bool TryAssertPoll <TActual>(ActualValueDelegate <TActual> del,
Func <IResolveConstraint> expression,
int?timeout)
{
int pollFor = timeout ?? RequestTimeout;
var constraint = expression().Resolve();
for (int i = 0; i < pollFor * 1000 / FAST_POLL_MILLISECONDS; i++)
{
try
{
var result = constraint.ApplyTo(del);
if (result.IsSuccess)
{
return(true); // break on success
}
}
catch { }
Thread.Sleep(FAST_POLL_MILLISECONDS);
} // continue with attempts until IsSuccess or RequestTimeout
return(false); // return on failure
}
/// <summary>
/// Apply a constraint to an actual value, succeeding if the constraint is satisfied
/// and throwing an assertion exception on failure.
/// </summary>
/// <typeparam name="TActual">The Type being compared.</typeparam>
/// <param name="del">An ActualValueDelegate returning the value to be tested</param>
/// <param name="expr">A Constraint expression to be applied</param>
public static void That <TActual>(ActualValueDelegate <TActual> del, IResolveConstraint expr)
{
PerformAssertWithConstraint <TActual>(expr, del);
}
/// <summary>
/// Apply a constraint to an actual value, succeeding if the constraint
/// is satisfied and throwing an InconclusiveException on failure.
/// </summary>
/// <param name="expr">A Constraint expression to be applied</param>
/// <param name="del">An ActualValueDelegate returning the value to be tested</param>
static public void That <TActual>(ActualValueDelegate <TActual> del, IResolveConstraint expr)
{
Assume.That(del, expr.Resolve(), null, null);
}
public override bool Matches(ActualValueDelegate del)
{
return(Matches(new ObjectInvocationDescriptor(del)));
}
public override bool Matches(ActualValueDelegate del)
{
try
{
var response = del();
actual = "SUCCESS";
return false; // the delegate must throw a ResourceException to indicate failure
}
catch (ResourceException ex)
{
actual = ex.Status;
return ex.Status == Status;
}
}
public override void ResolveFunc <T1>(
ActualValueDelegate <T1> actual,
IResolveConstraint constraint,
Func <string> message
) => Ignore.Unless(actual, constraint, message);
/// <summary>
/// Test whether the constraint is satisfied by an
/// ActualValueDelegate that returns the value to be tested.
/// The default implementation simply evaluates the delegate
/// but derived classes may override it to provide for delayed
/// processing.
/// </summary>
/// <param name="del">An <see cref="ActualValueDelegate" /></param>
/// <returns>True for success, false for failure</returns>
public virtual bool Matches(ActualValueDelegate del)
{
return(Matches(del()));
}
/// <summary>
/// Converts an ActualValueDelegate to a TestDelegate
/// before calling the primary overload.
/// </summary>
/// <param name="del"></param>
/// <returns></returns>
public override ConstraintResult ApplyTo <TActual>(ActualValueDelegate <TActual> del)
{
//TestDelegate testDelegate = new TestDelegate(delegate { del(); });
//return ApplyTo((object)testDelegate);
return(ApplyTo(new GenericInvocationDescriptor <TActual>(del)));
}
public void FailsWithBadDelegates(ActualValueDelegate<object> del)
{
Assert.IsFalse(theConstraint.ApplyTo(del).IsSuccess);
}
/// <summary>
/// Apply a constraint to an actual value, succeeding if the constraint
/// is satisfied and issuing a warning on failure.
/// </summary>
/// <typeparam name="TActual">The Type being compared.</typeparam>
/// <param name="del">An ActualValueDelegate returning the value to be tested</param>
/// <param name="expr">A Constraint expression to be applied</param>
public static void Unless <TActual>(ActualValueDelegate <TActual> del, IResolveConstraint expr)
{
Warn.Unless(del, expr.Resolve(), null, null);
}
public void SucceedsWithGoodDelegates(ActualValueDelegate<object> del)
{
SetValuesAfterDelay(300);
Assert.That(theConstraint.ApplyTo(del).IsSuccess);
}
public void that_e_true_com_actual_value_delegate_e_array_de_object_e_mensagem_deve_retornar_excecao_de_expressao()
{
string message = string.Empty;
try
{
IAssert assert = new RealAssert();
object[] lista = new object[0];
ActualValueDelegate del = new ActualValueDelegate(SuportDelegate);
ResolvableConstraintExpression expression = new ResolvableConstraintExpression();
assert.That(del, expression, "jhghjg");
}
catch (Exception ex)
{
message = ex.Message;
}
Assert.AreEqual(message, "A partial expression may not be resolved");
}
public void that_del_e_expression_mensagem_e_array_de_object_nao_deve_retornar_execao()
{
IAssert Assert = new FakeAssert();
object[] lista = new object[0];
ActualValueDelegate del = new ActualValueDelegate(dele);
ResolvableConstraintExpression expression = new ResolvableConstraintExpression();
Assert.That(del, expression, "", lista);
}
/// <summary>
/// Apply a constraint to an actual value, succeeding if the constraint is satisfied
/// and throwing an assertion exception on failure.
/// </summary>
/// <typeparam name="TActual">The Type being compared.</typeparam>
/// <param name="del">An ActualValueDelegate returning the value to be tested</param>
/// <param name="expr">A Constraint expression to be applied</param>
/// <param name="getExceptionMessage">A function to build the message included with the Exception</param>
public static void That <TActual>(ActualValueDelegate <TActual> del, IResolveConstraint expr, Func <string> getExceptionMessage)
{
PerformAssertWithConstraint <TActual>(expr, del, getExceptionMessage);
}
/// <summary>
/// Applies the constraint to an ActualValueDelegate that returns
/// the value to be tested. The default implementation simply evaluates
/// the delegate but derived classes may override it to provide for
/// delayed processing.
/// </summary>
/// <param name="del">An ActualValueDelegate</param>
/// <returns>A ConstraintResult</returns>
public override ConstraintResult ApplyTo <TActual>(ActualValueDelegate <TActual> del)
{
return(ApplyTo((Delegate)del));
}
/// <summary>
/// Apply a constraint to an actual value, succeeding if the constraint is satisfied
/// and throwing an assertion exception on failure.
/// </summary>
/// <typeparam name="TActual">The Type being compared.</typeparam>
/// <param name="del">An ActualValueDelegate returning the value to be tested</param>
/// <param name="expr">A Constraint expression to be applied</param>
/// <param name="message">The message that will be displayed on failure</param>
/// <param name="args">Arguments to be used in formatting the message</param>
public static void That <TActual>(ActualValueDelegate <TActual> del, IResolveConstraint expr, string message, params object[] args)
{
PerformAssertWithConstraint <TActual>(expr, del, message: message, args: args);
}
/// <summary>
/// Apply a constraint to an actual value, succeeding if the constraint
/// is satisfied and throwing an assertion exception on failure.
/// </summary>
/// <param name="del">An ActualValueDelegate returning the value to be tested</param>
/// <param name="expr">A Constraint expression to be applied</param>
/// <param name="message">The message that will be displayed on failure</param>
/// <param name="args">Arguments to be used in formatting the message</param>
public void Expect(ActualValueDelegate del, IResolveConstraint expr, string message, params object[] args)
{
Assert.That(del, expr, message, args);
}
public GenericInvocationDescriptor(ActualValueDelegate <T> del)
{
_del = del;
}
public void that_e_true_com_actual_value_delegate_e_resolve_constraint_e_mensagem_nao_deve_retornar_execao()
{
IAssert Assert = new FakeAssert();
object[] lista = new object[0];
ActualValueDelegate del = new ActualValueDelegate(dele);
ResolvableConstraintExpression expression = new ResolvableConstraintExpression();
Assert.That(del, expression, "mensagem");
}
public void TestConstructor2()
{
ActualValueDelegate <object> d = () => new Circle(double.NaN);
Assert.That(d, Throws.TypeOf <ArgumentException>());
}
/// <summary>
/// Apply a constraint to an actual value, succeeding if the constraint
/// is satisfied and throwing an InconclusiveException on failure.
/// </summary>
/// <param name="expr">A Constraint expression to be applied</param>
/// <param name="del">An ActualValueDelegate returning the value to be tested</param>
/// <param name="message">The message that will be displayed on failure</param>
static public void That(ActualValueDelegate del, IResolveConstraint expr, string message)
{
Assume.That(del, expr.Resolve(), message, null);
}
#pragma warning restore 3006
/// <summary>
/// Retrieves the value to be tested from an ActualValueDelegate.
/// The default implementation simply evaluates the delegate but derived
/// classes may override it to provide for delayed processing.
/// </summary>
/// <param name="del">An ActualValueDelegate</param>
/// <returns>Delegate evaluation result</returns>
protected virtual object GetTestObject <TActual>(ActualValueDelegate <TActual> del)
{
return(del());
}
public ConstraintResult ApplyTo <TActual>(ActualValueDelegate <TActual> del)
{
return(CaptureResult(resolvedParent.ApplyTo(del)));
}
/// <summary>
/// Apply a constraint to an actual value, succeeding if the constraint
/// is satisfied and throwing an assertion exception on failure.
/// </summary>
/// <param name="expr">A Constraint expression to be applied</param>
/// <param name="del">An ActualValueDelegate returning the value to be tested</param>
/// <param name="message">The message that will be displayed on failure</param>
public void Expect(ActualValueDelegate del, IResolveConstraint expr, string message)
{
Assert.That(del, expr.Resolve(), message, null);
}
public static void Check <T>(ActualValueDelegate <T> del, int count)
{
Check(del, count, 0.8);
}
/// <summary>
/// Apply a constraint to an actual value, succeeding if the constraint
/// is satisfied and throwing an assertion exception on failure.
/// </summary>
/// <param name="expr">A Constraint expression to be applied</param>
/// <param name="del">An ActualValueDelegate returning the value to be tested</param>
public void Expect(ActualValueDelegate del, IResolveConstraint expr)
{
Assert.That(del, expr.Resolve(), null, null);
}
public ObjectInvocationDescriptor(ActualValueDelegate del)
{
_del = del;
}
/// <summary>
/// Converts an ActualValueDelegate to a TestDelegate
/// before calling the primary overload.
/// </summary>
/// <param name="del"></param>
/// <returns></returns>
public override bool Matches(ActualValueDelegate del)
{
TestDelegate testDelegate = new TestDelegate(delegate { del(); });
return Matches((object)testDelegate);
}
public void SucceedsWithGoodDelegates(ActualValueDelegate del)
{
SetValueTrueAfterDelay(300);
Assert.That(theConstraint.Matches(del));
}
public override bool Matches <T>(ActualValueDelegate <T> del)
{
return(Matches(new GenericInvocationDescriptor <T>(del)));
}
public void FailsWithBadDelegates(ActualValueDelegate del)
{
Assert.IsFalse(theConstraint.Matches(del));
}
/// <summary>
/// Converts an ActualValueDelegate to a TestDelegate
/// before calling the primary overload.
/// </summary>
/// <param name="del"></param>
/// <returns></returns>
public override bool Matches(ActualValueDelegate del)
{
TestDelegate testDelegate = new TestDelegate(delegate { del(); });
return(Matches((object)testDelegate));
}
public void ValidateEmptyDataNullOrEmpty(string testData)
{
ActualValueDelegate <Object> testDelegate = () => Utilities.ValidateEmptyData(testData);
Assert.That(testDelegate, Throws.TypeOf <QuandlDataNotFoundException>());
}
