public Exercise(ILoggerService loggerService, ISpeechService speechService, string name, int setCount, int repetitionCount, IEnumerable<MatcherWithAction> matchersWithActions) { loggerService.AssertNotNull(nameof(loggerService)); speechService.AssertNotNull(nameof(speechService)); name.AssertNotNull(nameof(name)); matchersWithActions.AssertNotNull(nameof(matchersWithActions)); if (setCount < 0) { throw new ArgumentException("setCount cannot be less than zero.", "setCount"); } if (repetitionCount < 0) { throw new ArgumentException("repetitionCount cannot be less than zero.", "repetitionCount"); } this.logger = loggerService.GetLogger(this.GetType()); this.speechService = speechService; this.name = name; this.setCount = setCount; this.repetitionCount = repetitionCount; this.matchersWithActions = matchersWithActions.ToImmutableList(); using (var dummyExecutionContext = new ExecutionContext()) { this.duration = this .GetEventsWithActions(dummyExecutionContext) .SelectMany(x => x.Actions) .Select(x => x.Duration) .DefaultIfEmpty() .Aggregate((running, next) => running + next); } }
internal static void VerifyValuesCoverage(this IEnumerable <Enumeration> values, IDictionary <string, int> coverage) { /* This is a hard exception. If this occurs, we have other problems to contend with. * Think it through, there need to be at least One item in the Values array for this * to be useful. */ // ReSharper disable once InconsistentNaming var __values = values.AssertNotNull().AssertNotEmpty().ToArray(); try { // Then, we expect each of the Values to be Evaluated. __values.AssertEqual(coverage.Count, x => x.Length); // Each of the Values shall be Evaluated at least Once. coverage.Values.AssertTrue(x => x.All(count => count > 0)); } catch (Exception ex) { // TODO: TBD: Assert inconclusive how? i.e. NUnit provides Assert.Inconclusive(...). var incomplete = __values.Select(x => x.Name).Except(coverage.Keys) .Aggregate(Empty, (g, x) => IsNullOrEmpty(g) ? $"'{x}'" : $"{g}, '{x}'"); // TODO: TBD: for lack of a better way of signaling, just throw the IOEX here... throw new InvalidOperationException($"Incomplete test coverage: [ {incomplete} ]", ex); } }
public IList <LibraryReference> Distinct(IEnumerable <LibraryReference> references) { references.AssertNotNull(nameof(references)); var result = new Dictionary <LibraryId, LibraryReference>(); foreach (var reference in references) { var key = reference.Id; if (!result.TryGetValue(key, out var existing)) { result.Add(key, reference); } else { var shouldCombineFrameworks = ShouldCombine(existing.TargetFrameworks, reference.TargetFrameworks); var shouldCombineInternal = existing.IsInternal != reference.IsInternal; if (shouldCombineFrameworks || shouldCombineInternal) { var targetFrameworks = shouldCombineFrameworks ? existing.TargetFrameworks.Union(reference.TargetFrameworks, StringComparer.OrdinalIgnoreCase).ToArray() : existing.TargetFrameworks; var isInternal = existing.IsInternal && reference.IsInternal; result[key] = new LibraryReference( key, targetFrameworks, existing.Dependencies.Union(reference.Dependencies).ToArray(), isInternal); } } } return(new List <LibraryReference>(result.Values)); }
public static TResult SelectLast <TSource, TResult>(this IEnumerable <TSource> source, Func <TSource, TResult> selector) { source.AssertNotNull("source"); selector.AssertNotNull("selector"); return(source.Select(selector).LastOrDefault()); }
public static IEnumerable <OuterLinqJoinResult <TOuter, TInner> > LeftJoin <TOuter, TInner, TKey>(this IEnumerable <TOuter> outer, IEnumerable <TInner> inner, Func <TOuter, TKey> outerKeySelector, Func <TInner, TKey> innerKeySelector, IEqualityComparer <TKey> comparer) { inner.AssertNotNull("outer"); outer.AssertNotNull("outer"); return (outer .GroupJoin ( inner, outerKeySelector, innerKeySelector, (x, y) => new { LeftPart = x, RightPart = y }, comparer ) .SelectMany ( x => x.RightPart.DefaultIfEmpty(), (x, y) => new OuterLinqJoinResult <TOuter, TInner> { LeftPart = x.LeftPart, RightPart = y } )); }
public Task <bool> IsInAllRolesAsync(Requester requester, IEnumerable <string> roles) { requester.AssertNotNull("requester"); roles.AssertNotNull("roles"); roles = this.CheckRoles(roles); return(Task.FromResult(roles.Where(v => v != null).All(requester.IsInRole))); }
public Exercise(ILoggerService loggerService, ISpeechService speechService, string name, int setCount, int repetitionCount, IEnumerable <MatcherWithAction> matchersWithActions) { loggerService.AssertNotNull(nameof(loggerService)); speechService.AssertNotNull(nameof(speechService)); name.AssertNotNull(nameof(name)); matchersWithActions.AssertNotNull(nameof(matchersWithActions)); if (setCount < 0) { throw new ArgumentException("setCount cannot be less than zero.", "setCount"); } if (repetitionCount < 0) { throw new ArgumentException("repetitionCount cannot be less than zero.", "repetitionCount"); } this.logger = loggerService.GetLogger(this.GetType()); this.speechService = speechService; this.name = name; this.setCount = setCount; this.repetitionCount = repetitionCount; this.matchersWithActions = matchersWithActions.ToImmutableList(); using (var dummyExecutionContext = new ExecutionContext()) { this.duration = this .GetEventsWithActions(dummyExecutionContext) .SelectMany(x => x.Actions) .Select(x => x.Duration) .DefaultIfEmpty() .Aggregate((running, next) => running + next); } }
public void RegisterAllDefinitions(IEnumerable <IDialogDefinition> definitions) { definitions.AssertNotNull(nameof(definitions)); foreach (var definition in definitions) { RegisterDialogDefinition(definition); } }
public static string BuildUsedBy(IEnumerable <PackageApplication> usedBy) { usedBy.AssertNotNull(nameof(usedBy)); var list = usedBy.Select(i => i.InternalOnly ? i.Name + " internal" : i.Name).OrderBy(i => i); return(string.Join(", ", list)); }
/// <summary> /// Initializes a new instance of the <see cref="OfferLogoMatcher"/> class. /// </summary> /// <param name="keywords">The keywords to match the offer product name against.</param> /// <param name="logo">The offer logo to use in case of a match.</param> public OfferLogoMatcher(IEnumerable <string> keywords, string logo) { keywords.AssertNotNull(nameof(keywords)); logo.AssertNotEmpty("logo URI can't be empty"); this.logo = logo; this.keywords = new List <string>(keywords); }
public static IEnumerable <object> ToGenericEnumerable(this IEnumerable collection) { collection.AssertNotNull("Enumeration"); foreach (var element in collection) { yield return(element); } }
public SqlQueryBuilder Select(IEnumerable <SelectField> fields) { fields.AssertNotNull(nameof(fields)); fields = fields.Select(x => new SelectField(DAOHelper.EscapeField(x.Field), x.Alias)); _selectFields = fields; return(this); }
public void AssertNotNullOnNullEnumerableThrowsArgumentNullException() { IEnumerable sut = null; var ex = Assert.Throws <ArgumentNullException>(() => sut.AssertNotNull(true, "sut")); Assert.Equal("sut", ex.ParamName); }
public static void ForEach <T>(this IEnumerable <T> collection, Action <T> action) { action.AssertParameterNotNull(nameof(action)); foreach (var element in collection.AssertNotNull("Enumeration")) { action(element); } }
public static IReadOnlyList <TRes> SelectToReadOnlyList <T, TRes>(this IEnumerable <T> source, Func <T, TRes> mapper) { if (source is IReadOnlyList <T> list) { return(SelectToReadOnlyList(list, mapper)); } return(source.AssertNotNull($"\"{nameof(source)}\" cannot be null").Select(mapper).ToList()); }
private void Initialize(IEnumerable <Tuple <TKey, IEnumerable <TValue> > > data) { data.AssertNotNull(nameof(data)); foreach (var item in data) { _dict.Add(item.Item1, new EnumeratorWrapper <TValue>(item.Item2.ToEmptyIfNull())); } }
public static void AssertAreNotNull <T>(this IEnumerable <T> me) { me.AssertNotNull(); foreach (var item in me) { item.AssertNotNull(); } }
public void AddRange(IEnumerable <T> items) { items.AssertNotNull(nameof(items)); foreach (var item in items) { Add(item); } }
/// <summary> /// Writes a record to this <c>CsvWriter</c>. /// </summary> /// <remarks> /// Any <see langword="null"/> values will be written as empty strings. /// </remarks> /// <param name="values"> /// The values comprising the record. /// </param> public void WriteRecord(IEnumerable <string> values) { Debug.Assert(this.bufferBuilder.Length == 0, "Expecting buffer to be empty."); this.EnsureNotDisposed(); values.AssertNotNull("values"); this.WriteRecordToBuffer(values); this.FlushBufferToTextWriter(); }
/// <summary> /// Asynchronously writes a record to this <c>CsvWriter</c>. /// </summary> /// <remarks> /// None of the <see cref="System.String"/>s within <paramref name="values"/> can be <see langword="null"/>. If so, an exception will be thrown. /// </remarks> /// <param name="values"> /// The values comprising the record. /// </param> /// <returns> /// A <see cref="Task"/> representing the asynchronous operation. /// </returns> public async Task WriteRecordAsync(IEnumerable<string> values) { Debug.Assert(this.bufferBuilder.Length == 0, "Expecting buffer to be empty."); this.EnsureNotDisposed(); values.AssertNotNull("values"); this.WriteRecordToBuffer(values); await this.FlushBufferToTextWriterAsync().ConfigureAwait(false); }
/// <summary> /// Asynchronously writes a record to this <c>CsvWriter</c>. /// </summary> /// <remarks> /// None of the <see cref="System.String"/>s within <paramref name="values"/> can be <see langword="null"/>. If so, an exception will be thrown. /// </remarks> /// <param name="values"> /// The values comprising the record. /// </param> /// <returns> /// A <see cref="Task"/> representing the asynchronous operation. /// </returns> public async Task WriteRecordAsync(IEnumerable <string> values) { Debug.Assert(this.bufferBuilder.Length == 0, "Expecting buffer to be empty."); this.EnsureNotDisposed(); values.AssertNotNull("values"); this.WriteRecordToBuffer(values); await this.FlushBufferToTextWriterAsync().ConfigureAwait(false); }
public static void PushAll <T>(this Stack <T> stack, IEnumerable <T> items) { stack.AssertNotNull(nameof(stack)); items.AssertNotNull(nameof(items)); foreach (T item in items) { stack.Push(item); } }
/// <summary> /// Creates a new NetNode with the specified fields. /// </summary> /// <param name="guid">The unique Id for the computer.</param> /// <param name="name">The user friendly name for the computer.</param> /// <param name="uri">The computer's Uri, if it has one.</param> /// <param name="edges">Edges from this computer to others.</param> public NetNode(Guid guid, string name, Uri uri, IEnumerable <INetEdge> edges) { guid.AssertNotNull(nameof(guid)); name.AssertNotNullOrEmptyOrWhitespace(nameof(name)); edges.AssertNotNull(nameof(edges)); this.guid = guid; this.name = name; this.edges = edges.ToImmutableDictionary(edge => edge.Destination.Guid, edge => edge); }
public MetronomeAction(IAudioService audioService, IDelayService delayService, ILoggerService loggerService, IEnumerable <MetronomeTick> ticks) { audioService.AssertNotNull(nameof(audioService)); delayService.AssertNotNull(nameof(delayService)); loggerService.AssertNotNull(nameof(loggerService)); ticks.AssertNotNull(nameof(ticks)); this.ticks = ticks.ToImmutableList(); this.innerAction = new SequenceAction(GetInnerActions(audioService, delayService, loggerService, this.ticks)); }
/// <summary> /// Initializes a new instance of the <see cref="AuthenticationParameters" /> class. /// </summary> protected AuthenticationParameters(MgmtAccount account, MgmtEnvironment environment, IEnumerable <string> scopes) { account.AssertNotNull(nameof(account)); environment.AssertNotNull(nameof(environment)); scopes.AssertNotNull(nameof(scopes)); Account = account; Environment = environment; Scopes = scopes; }
public static IEnumerable <T> ExcludeDefaultValues <T>(this IEnumerable <T> collection) { foreach (var element in collection.AssertNotNull("Enumeration")) { if (!EqualityComparer <T> .Default.Equals(element, default(T))) { yield return(element); } } }
public static ObservableCollection <T> ToObservableCollection <T>(this IEnumerable <T> collection) { var observableCollection = new ObservableCollection <T>(); foreach (var element in collection.AssertNotNull("Enumeration")) { observableCollection.Add(element); } return(observableCollection); }
public static Stack <T> ToStack <T>(this IEnumerable <T> collection) { var stack = new Stack <T>(); foreach (var element in collection.AssertNotNull("Enumeration")) { stack.Push(element); } return(stack); }
public static Queue <T> ToQueue <T>(this IEnumerable <T> collection) { var queue = new Queue <T>(); foreach (var element in collection.AssertNotNull("Enumeration")) { queue.Enqueue(element); } return(queue); }
/// <summary> /// Creates a new NetNode with the specified fields. /// </summary> /// <param name="guid">The unique Id for the computer.</param> /// <param name="name">The user friendly name for the computer.</param> /// <param name="uri">The computer's Uri, if it has one.</param> /// <param name="edges">Edges from this computer to others.</param> public NetNode(Guid guid, string name, Uri uri, IEnumerable<INetEdge> edges) { guid.AssertNotNull(nameof(guid)); name.AssertNotNullOrEmptyOrWhitespace(nameof(name)); edges.AssertNotNull(nameof(edges)); this.guid = guid; this.name = name; this.edges = edges.ToImmutableDictionary(edge => edge.Destination.Guid, edge => edge); }
public MetronomeAction(IAudioService audioService, IDelayService delayService, ILoggerService loggerService, IEnumerable<MetronomeTick> ticks) { audioService.AssertNotNull(nameof(audioService)); delayService.AssertNotNull(nameof(delayService)); loggerService.AssertNotNull(nameof(loggerService)); ticks.AssertNotNull(nameof(ticks)); this.ticks = ticks.ToImmutableList(); this.innerAction = new SequenceAction(GetInnerActions(audioService, delayService, loggerService, this.ticks)); }
public static bool IsSingleElement <T>(this IEnumerable <T> collection) { collection.AssertNotNull(nameof(collection)); if (collection is ICollection list) { return(list.Count == 1); } using (var iter = collection.GetEnumerator()) { return(iter.MoveNext() && !iter.MoveNext()); } }
public ParallelAction(IEnumerable<IAction> children) { children.AssertNotNull(nameof(children), assertContentsNotNull: true); this.children = children.ToImmutableList(); this.duration = this .children .Select(x => x.Duration) .DefaultIfEmpty() .Max(); }
public static IList <Tuple <TResult> > ToTupleList <TSource, TResult>(this IEnumerable <TSource> source, Func <TSource, TResult> selector) { source.AssertNotNull("source"); selector.AssertNotNull("selector"); return (source .ToEmptyIfNull() .Select(x => new Tuple <TResult>(selector(x))) .ToList()); }
public SequenceAction(IEnumerable <IAction> children) { children.AssertNotNull(nameof(children), assertContentsNotNull: true); this.children = children.ToImmutableList(); this.duration = this .children .Select(x => x.Duration) .DefaultIfEmpty() .Aggregate((running, next) => running + next); }
/// <summary> /// Creates a new NetGraph representation from raw data. /// </summary> /// <param name="nodes"> /// A list of all nodes. The first node is assumed to be this computer. /// </param> private NetGraph(IEnumerable<INetNode> nodes) { nodes.AssertNotNull(nameof(nodes)); if (nodes.FirstOrDefault() != null) { this.thisNode = nodes.First(); } this.nodes = nodes.ToImmutableDictionary(edge => edge.Guid, edge => edge); }
public SequenceAction(IEnumerable<IAction> children) { children.AssertNotNull(nameof(children), assertContentsNotNull: true); this.children = children.ToImmutableList(); this.duration = this .children .Select(x => x.Duration) .DefaultIfEmpty() .Aggregate((running, next) => running + next); }
public IRace Create(IDistanceCalculator distanceCalculator, IEnumerable<Waypoint> waypoints) { distanceCalculator.AssertNotNull(); waypoints = waypoints as List<Waypoint> ?? waypoints.ToList(); waypoints.AssertNotEmpty(); waypoints.AssertNotNull(); var Race = new RaceService(distanceCalculator, waypoints); return Race; }
/// <summary> /// Determines whether the principal contains the specified claims. /// </summary> /// <param name="principal">The principal.</param> /// <param name="claims">The claims.</param> /// <returns><c>true</c> if the principal contains the specified claims; otherwise, <c>false</c>.</returns> /// <exception cref="ArgumentNullException"><paramref name="claims"/> is <see langword="null"/>.</exception> /// <exception cref="ArgumentException"> /// One of the items in the <paramref name="claims"/> collection is <see langword="null"/>. /// </exception> public static bool HasClaims(this ClaimsPrincipal principal, IEnumerable<Claim> claims) { claims.AssertNotNull(true, "claims"); foreach (var claim in claims) { if (!principal.HasClaim(claim.Type, claim.Value)) { return false; } } return true; }
/// <summary> /// Determines whether the principal contains the specified claim types. /// </summary> /// <param name="principal">The principal.</param> /// <param name="claimTypes">The claim types.</param> /// <returns> /// <c>true</c> if the principal contains the specified claim types; otherwise, <c>false</c>. /// </returns> /// <exception cref="ArgumentNullException"> /// <paramref name="claimTypes"/> is <see langword="null"/>. /// </exception> /// <exception cref="ArgumentException"> /// One of the items in the <paramref name="claimTypes"/> collection is <see langword="null"/>. /// </exception> public static bool HasClaimTypes(this ClaimsPrincipal principal, IEnumerable<string> claimTypes) { claimTypes.AssertNotNull(true, "claimTypes"); foreach (var type in claimTypes) { if (!principal.HasClaim(c => c.Type == type)) { return false; } } return true; }
public ExerciseProgram(ILoggerService loggerService, string name, IEnumerable<Exercise> exercises) { loggerService.AssertNotNull(nameof(loggerService)); name.AssertNotNull(nameof(name)); exercises.AssertNotNull(nameof(exercises), assertContentsNotNull: true); this.logger = loggerService.GetLogger(this.GetType()); this.name = name; this.exercises = exercises.ToImmutableList(); this.duration = this .exercises .Select(x => x.Duration) .DefaultIfEmpty() .Aggregate((running, next) => running + next); }
public JsonSyntaxNode(IEnumerable<JsonSyntaxNode> children) { children.AssertNotNull(); this.children = new ReadOnlyCollection<JsonSyntaxNode>(children.ToList()); }
public ExercisePrograms(IEnumerable<ExerciseProgram> programs) { programs.AssertNotNull(nameof(programs), assertContentsNotNull: true); this.programs = programs.ToImmutableList(); }
/// <summary> /// Initializes a new instance of the HeaderRecord class. /// </summary> /// <param name="columnNames"> /// The names of the columns in the header record. /// </param> /// <param name="readOnly"> /// <see langword="true"/> if the header record is read-only, otherwise <see langword="false"/>. /// </param> public HeaderRecord(bool readOnly, IEnumerable<string> columnNames) : base(readOnly, columnNames) { columnNames.AssertNotNull("columnNames", true); this.columnNameToIndexMap = new Dictionary<string, int>(); this.PopulateColumnNameToIndexMap(0, true); if (readOnly) { this.columnNameToIndexMap = new ReadOnlyDictionary<string, int>(this.columnNameToIndexMap); } }
/// <summary> /// Writes a record to this <c>CsvWriter</c>. /// </summary> /// <remarks> /// Any <see langword="null"/> values will be written as empty strings. /// </remarks> /// <param name="values"> /// The values comprising the record. /// </param> public void WriteRecord(IEnumerable<string> values) { Debug.Assert(this.bufferBuilder.Length == 0, "Expecting buffer to be empty."); this.EnsureNotDisposed(); values.AssertNotNull("values"); this.WriteRecordToBuffer(values); this.FlushBufferToTextWriter(); }