public UnaryNotAssertion(IAssertion operand) { if (operand == null) throw new ArgumentNullException("operand"); _operand = operand; }
protected CompositeAssertion(IAssertion[] assertions) { if (assertions == null) throw new ArgumentNullException("assertions"); foreach (IAssertion assertion in assertions) { if (assertion == null) throw new ArgumentException(null, "assertions"); } InnerList.AddRange(assertions); }
public static string AssertionToString(IAssertion assertion) { string assertionDisplay = "NULL"; if (assertion != null) { assertionDisplay = string.Format( "ValidFromDate>{0}< " + "ValidUntilDate>{1}< " + "PrincipalName>{2}< " + "Attributes Count>{3}<", assertion.ValidFromDate, assertion.ValidUntilDate, assertion.PrincipalName, assertion.Attributes.Count); } return assertionDisplay; }
/// <summary> /// Initializes the module and prepares it to handle requests. /// </summary> public virtual void Init(HttpApplication application) { if (application == null) throw new ArgumentNullException("application"); var config = (ErrorFilterConfiguration) Configuration.GetSubsection("errorFilter"); if (config == null) return; _assertion = config.Assertion; foreach (var module in HttpModuleRegistry.GetModules(application)) { var filtering = module as IExceptionFiltering; if (filtering != null) filtering.Filtering += OnErrorModuleFiltering; } }
public static void Inconclusive(this IAssertion assertion, System.String message, System.Object[] parameters) { Assert.Inconclusive(message, parameters); }
public static void Fail(this IAssertion assertion, System.String message, System.Object[] parameters) { Assert.Fail(message, parameters); }
/// <summary> /// Constructs a new Principal backed by the supplied Assertion, with /// proxying capabilities. /// </summary> /// <param name="assertion"> /// the Assertion that backs this Principal /// </param> /// <param name="proxyGrantingTicket"> /// the proxy granting ticket associated with this Principal. /// </param> /// <param name="proxies"> /// The proxy path associated with this Principal /// </param> public CasPrincipal(IAssertion assertion, string proxyGrantingTicket, IEnumerable<string> proxies) { Argument.ThrowIfNull(assertion, "assertion", "assertion cannot be null."); Identity = new GenericIdentity(assertion.PrincipalName, CAS_AUTH_TYPE); Assertion = assertion; ProxyGrantingTicket = proxyGrantingTicket; Proxies = proxies ?? Enumerable.Empty<string>(); }
internal void SetAssertion(IAssertion assertion) { _assertion = assertion != null ? assertion : StaticAssertion.False; }
public virtual int IndexOf(IAssertion assertion) { return InnerList.IndexOf(assertion); }
public virtual int IndexOf(IAssertion assertion) { return(InnerList.IndexOf(assertion)); }
public static Exception ThrowsAsync(this IAssertion assertion, Task task, ExceptionInheritanceOptions inheritOptions = ExceptionInheritanceOptions.Inherits) { return(ThrowsAsync <Exception>(task, null, ExceptionMessageCompareOptions.None, inheritOptions)); }
/// <summary> /// Add assertion to the list /// </summary> /// <param name="assertion"></param> public bool Remove(IAssertion assertion) { return(_assertionsByName.Remove(assertion.Name)); }
public virtual bool Contains(IAssertion assertion) { return(InnerList.Contains(assertion)); }
/// <summary> /// Add assertion to the list /// </summary> /// <param name="assertion"></param> public void Add(IAssertion assertion) { _assertionsByName.Add(assertion.Name, assertion); }
private static Exception IsTrueForAnyActHelper(IAssertion<IEnumerable<bool>> values) { return CollectionActHelper(values, CollectionExtensions.IsTrueForAny(values, v => v)); }
private static Exception CollectionActHelper(IAssertion<IEnumerable<bool>> values, IVerifiable<IEnumerable<bool>> action) { Exception x = null; try { action.Now(); } catch (Exception e) { x = e; } return x; }
public static void Inconclusive(this IAssertion assertion, System.String message) { Assert.Inconclusive(message); }
/// <summary> /// Constructs a new Principal backed by the supplied Assertion, with proxying cabilities. /// </summary> /// <param name="assertion">the Assertion that backs this Principal</param> /// <param name="proxyGrantingTicket"> /// the proxy granting ticket associated with this Principal. /// </param> /// <param name="proxyRetriever"> /// the ProxyRetriever to call back to the CAS server. /// </param> public CasPrincipal(IAssertion assertion, string proxyGrantingTicket, IProxyRetriever proxyRetriever) { CommonUtils.AssertNotNull(assertion, "assertion cannot be null."); this.Identity = new GenericIdentity(assertion.PrincipalName, CommonUtils.CAS_AUTH_TYPE); this.Assertion = assertion; this.proxyGrantingTicket = proxyGrantingTicket; this.proxyRetriever = proxyRetriever; }
public static string AssertionToString(IAssertion assertion, string newLineDelim, string initialLineIndent, int initialLineIndentCount, string dataDelim, bool useDelimAlways) { StringBuilder sb = new StringBuilder(); string lineIndent = GenerateLineIndent(initialLineIndent, initialLineIndentCount); sb.Append(string.Format("{0}Assertion:{1}", lineIndent, newLineDelim)); int memberLineIndentCount = initialLineIndentCount + 2; string memberLineIndent = GenerateLineIndent(initialLineIndent, memberLineIndentCount); if (assertion == null) { sb.Append(string.Format("{0}UNDEFINED{1}", memberLineIndent, newLineDelim)); } else { sb.Append(string.Format("{0}ValidFromDate: {1}{2}", memberLineIndent, DataNullEmptyDisplay(assertion.ValidFromDate.ToString(), dataDelim, useDelimAlways), newLineDelim)); sb.Append(string.Format("{0}ValidUntilDate: {1}{2}", memberLineIndent, DataNullEmptyDisplay(assertion.ValidUntilDate.ToString(), dataDelim, useDelimAlways), newLineDelim)); sb.Append(string.Format("{0}PrincipalName: {1}{2}", memberLineIndent, DataNullEmptyDisplay(assertion.PrincipalName, dataDelim, useDelimAlways), newLineDelim)); sb.Append(AttributesToString(assertion.Attributes, newLineDelim, initialLineIndent, memberLineIndentCount, dataDelim, useDelimAlways)); } return sb.ToString(); }
public static IAssertionResult <T, TSource> Assert <T, TSource>(this IValueProvider <T, TSource> valueProvider, IAssertion <T> assertion, IAssertionConfiguration configuration) { return(Wait.Assertion(valueProvider, new AssertionConfiguration <T> { Timeout = configuration.Timeout, Interval = configuration.Interval, ExceptionMatcher = configuration.ExceptionMatcher, Assertion = assertion })); }
public static T ThrowsAsync <T>(this IAssertion assertion, Task task, string expectedMessage, ExceptionMessageCompareOptions options, ExceptionInheritanceOptions inheritOptions = ExceptionInheritanceOptions.Inherits) where T : Exception { return(ThrowsAsync <T>(task, expectedMessage, options, inheritOptions)); }
/// <summary> /// Add assertion to the list /// </summary> /// <param name="assertion"></param> public bool Remove(IAssertion assertion) { return _assertionsByName.Remove(assertion.Name); }
/// <summary> /// Public CasAuthenticationTicket constructor /// </summary> /// <param name="serviceTicket">CAS Service Ticket associated with this CasAuthenticationTicket</param> /// <param name="originatingServiceName">ServiceName used during CAS authentication/validation</param> /// <param name="clientHostAddress">IP address of the client initiating the authentication request</param> /// <param name="assertion">CAS assertion returned from the CAS server during ticket validation</param> public CasAuthenticationTicket(string serviceTicket, string originatingServiceName, string clientHostAddress, IAssertion assertion) { CasAuthentication.Initialize(); Proxies = new List<string>(); NetId = assertion.PrincipalName; ServiceTicket = serviceTicket; OriginatingServiceName = originatingServiceName; ClientHostAddress = clientHostAddress; Assertion = assertion; if (DateTime.MinValue.CompareTo(assertion.ValidFromDate) != 0) { ValidFromDate = assertion.ValidFromDate; } else { ValidFromDate = DateTime.Now; } DateTime localValidUntil = ValidFromDate.Add(CasAuthentication.FormsTimeout); if (DateTime.MinValue.CompareTo(assertion.ValidUntilDate) != 0) { ValidUntilDate = localValidUntil.CompareTo(assertion.ValidUntilDate) < 0 ? localValidUntil : assertion.ValidUntilDate; } else { ValidUntilDate = localValidUntil; } }
public static LogicalAssertion LogicalNot(IAssertion[] operands) { return new LogicalAssertion(operands, true, true); }
public static void AreNotEqual(this IAssertion assertion, System.String notExpected, System.String actual, System.Boolean ignoreCase, System.Globalization.CultureInfo culture) { Assert.AreNotEqual(notExpected, actual, ignoreCase, culture); }
public orAssertion(IAssertion one, IAssertion other) { this.one = one; this.other = other; }
public static void AreNotEqual(this IAssertion assertion, System.String notExpected, System.String actual, System.Boolean ignoreCase, System.Globalization.CultureInfo culture, System.String message, System.Object[] parameters) { Assert.AreNotEqual(notExpected, actual, ignoreCase, culture, message, parameters); }
public static void Fail(this IAssertion assertion) { Assert.Fail(); }
public static void AreNotEqual(this IAssertion assertion, System.Double notExpected, System.Double actual, System.Double delta) { Assert.AreNotEqual(notExpected, actual, delta); }
public static void Fail(this IAssertion assertion, System.String message) { Assert.Fail(message); }
public static void AreEqual <T>(this IAssertion assertion, T expected, T actual) { Assert.AreEqual(expected, actual); }
public static void AreEqual(this IAssertion assertion, System.String expected, System.String actual, System.Boolean ignoreCase) { Assert.AreEqual(expected, actual, ignoreCase); }
/// <summary> /// Constructs a new Principal backed by the supplied Assertion. /// </summary> /// <param name="assertion"> /// the Assertion that backs this Principal /// </param> public CasPrincipal(IAssertion assertion) : this(assertion, null, null) { }
public static void Inconclusive(this IAssertion assertion) { Assert.Inconclusive(); }
/// <summary> /// Constructs a new Principal backed by the supplied Assertion, with /// proxying capabilities. /// </summary> /// <param name="assertion"> /// the Assertion that backs this Principal /// </param> /// <param name="proxyGrantingTicket"> /// the proxy granting ticket associated with this Principal. /// </param> /// <param name="proxies"> /// The proxy path associated with this Principal /// </param> public CasPrincipal(IAssertion assertion, string proxyGrantingTicket, IEnumerable<string> proxies) { CommonUtils.AssertNotNull(assertion, "assertion cannot be null."); Identity = new GenericIdentity(assertion.PrincipalName, CasClientConfiguration.Config.AuthenticationType); Assertion = assertion; ProxyGrantingTicket = proxyGrantingTicket; if (proxies != null) { Proxies = proxies; } else { Proxies = new List<string>(); } }
public static void AreNotEqual(this IAssertion assertion, System.Single notExpected, System.Single actual, System.Single delta, System.String message, System.Object[] parameters) { Assert.AreNotEqual(notExpected, actual, delta, message, parameters); }
public static Exception ThrowsAsync(this IAssertion assertion, Task task, string expectedMessage, ExceptionInheritanceOptions inheritOptions = ExceptionInheritanceOptions.Inherits) { return(ThrowsAsync <Exception>(task, expectedMessage, ExceptionMessageCompareOptions.Exact, inheritOptions)); }
/// <summary> /// Constructs a new Principal backed by the supplied Assertion, with /// proxying capabilities. /// </summary> /// <param name="assertion"> /// the Assertion that backs this Principal /// </param> /// <param name="proxyGrantingTicket"> /// the proxy granting ticket associated with this Principal. /// </param> public CasPrincipal(IAssertion assertion, string proxyGrantingTicket) : this(assertion, proxyGrantingTicket, null) { }
public static void AreNotEqual(this IAssertion assertion, System.String notExpected, System.String actual, System.Boolean ignoreCase, System.String message) { Assert.AreNotEqual(notExpected, actual, ignoreCase, message); }
public AndAssertion(Assertion one, Assertion other) { this.one = one; this.other = other; }
public static void AreNotEqual <T>(this IAssertion assertion, T notExpected, T actual) { Assert.AreNotEqual(notExpected, actual); }
public virtual bool Contains(IAssertion assertion) { return InnerList.Contains(assertion); }
public static void AreNotEqual <T>(this IAssertion assertion, T notExpected, T actual, System.String message, System.Object[] parameters) { Assert.AreNotEqual(notExpected, actual, message, parameters); }
//public NotAssertion(IAssertion assertion) : base(assertion.Candidate, assertion.Message) public NotAssertion(IAssertion assertion) : base(assertion.Specification, assertion.Message) { wrapped = assertion; }
public static void AreNotSame(this IAssertion assertion, System.Object notExpected, System.Object actual, System.String message) { Assert.AreNotSame(notExpected, actual, message); }
public static IAssertion[] Create(XmlNodeList nodes) { if (nodes == null) throw new ArgumentNullException("nodes"); // // First count the number of elements, which will be used to // allocate the array at its correct and final size. // var elementCount = 0; foreach (XmlNode child in nodes) { var nodeType = child.NodeType; // // Skip comments and whitespaces. // if (nodeType == XmlNodeType.Comment || nodeType == XmlNodeType.Whitespace) continue; // // Otherwise all elements only. // if (nodeType != XmlNodeType.Element) { throw new ConfigurationException( string.Format("Unexpected type of node ({0}).", nodeType.ToString()), child); } elementCount++; } // // In the second pass, create and configure the assertions // from each element. // var assertions = new IAssertion[elementCount]; elementCount = 0; foreach (XmlNode node in nodes) { if (node.NodeType == XmlNodeType.Element) assertions[elementCount++] = Create((XmlElement) node); } return assertions; }
public static void AreEqual <T>(this IAssertion assertion, T expected, T actual, System.String message) { Assert.AreEqual(expected, actual, message); }
private LogicalAssertion(IAssertion[] assertions, bool not, bool all) : base(assertions) { _not = not; _all = all; }
public static void AreNotSame(this IAssertion assertion, System.Object notExpected, System.Object actual) { Assert.AreNotSame(notExpected, actual); }
public static LogicalAssertion LogicalOr(IAssertion[] operands) { return new LogicalAssertion(operands, false, false); }
public static void AreSame(this IAssertion assertion, System.Object expected, System.Object actual) { Assert.AreSame(expected, actual); }
public static void AreSame(this IAssertion assertion, System.Object expected, System.Object actual, System.String message, System.Object[] parameters) { Assert.AreSame(expected, actual, message, parameters); }
public static void Equals(this IAssertion assertion, System.Object objA, System.Object objB) { Assert.Equals(objA, objB); }
/// <summary> /// Public CasAuthenticationTicket constructor /// </summary> /// <param name="serviceTicket">CAS Service Ticket associated with this CasAuthenticationTicket</param> /// <param name="originatingServiceName">ServiceName used during CAS authentication/validation</param> /// <param name="clientHostAddress">IP address of the client initiating the authentication request</param> /// <param name="assertion">CAS assertion returned from the CAS server during ticket validation</param> /// <param name="clock"></param> public CasAuthenticationTicket( string serviceTicket, string originatingServiceName, string clientHostAddress, IAssertion assertion, DateTime validFromDate) { Proxies = new List<string>(); NetId = assertion.PrincipalName; ServiceTicket = serviceTicket; OriginatingServiceName = originatingServiceName; ClientHostAddress = clientHostAddress; Assertion = assertion; if (DateTime.MinValue.CompareTo(assertion.ValidFromDate) != 0) { ValidFromDate = assertion.ValidFromDate; } else { ValidFromDate = validFromDate; } DateTime localValidUntil = ValidFromDate.Add(TimeSpan.FromDays(30)); if (DateTime.MinValue.CompareTo(assertion.ValidUntilDate) != 0) { ValidUntilDate = localValidUntil.CompareTo(assertion.ValidUntilDate) < 0 ? localValidUntil : assertion.ValidUntilDate; } else { ValidUntilDate = localValidUntil; } }
public AbstractTestBase(IAssertion assertion) { context = new TestHttpContext(); Assert = assertion; }