private async Task FailureTest(Fail failCode, int numOfFailures) { this.HostedCluster.StartAdditionalSilos(numAdditionalSilos); await this.HostedCluster.WaitForLivenessToStabilizeAsync(); List<SiloHandle> failures = await getSilosToFail(failCode, numOfFailures); foreach (SiloHandle fail in failures) // verify before failure { VerificationScenario(PickKey(fail.SiloAddress)); // fail.SiloAddress.GetConsistentHashCode()); } logger.Info("FailureTest {0}, Code {1}, Stopping silos: {2}", numOfFailures, failCode, Utils.EnumerableToString(failures, handle => handle.SiloAddress.ToString())); List<uint> keysToTest = new List<uint>(); foreach (SiloHandle fail in failures) // verify before failure { keysToTest.Add(PickKey(fail.SiloAddress)); //fail.SiloAddress.GetConsistentHashCode()); this.HostedCluster.StopSilo(fail); } await this.HostedCluster.WaitForLivenessToStabilizeAsync(); AssertEventually(() => { foreach (var key in keysToTest) // verify after failure { VerificationScenario(key); } }, failureTimeout); }
public virtual void testSomeAllFailures() { Fail f = new Fail(); Some some = new Some(logVisitor(f)); Logger expected = new Logger(f, new IVisitable[]{n1,n2}); IVisitable nodeReturned = null; try { nodeReturned = some.visit(n0); } catch (VisitFailure) { Assertion.AssertEquals(expected, logger); Assertion.AssertNull(nodeReturned); } }
public virtual void testOnceTopDownFail() { IVisitor f = new Fail(); OnceTopDown onceTopDown = new OnceTopDown(logVisitor(f)); Logger expected = new Logger(f, new IVisitable[]{n0,n1,n11,n12,n2}); IVisitable nodeReturned = null; try { nodeReturned = onceTopDown.visit(n0); Assertion.Fail("VisitFailure should have occured!"); } catch (VisitFailure) { Assertion.AssertEquals("visit trace",expected, logger); Assertion.AssertNull("return value",nodeReturned); } }
// throws VisitFailure public virtual void testTrueFailingThen() { Fail failingThen = new Fail(); Logger expected = new Logger(); expected.log( new Event( failingThen, n0 ) ); try { nodeReturned = new IfThenElse( new Identity(), logVisitor(failingThen), logVisitor(idFalse)).visit(n0); Assertion.Fail(); } catch(VisitFailure) { Assertion.AssertEquals("trace", expected, logger); Assertion.AssertNull("returned node", nodeReturned); } }
public static Limb TransitionTo (Limb from, Analyzer.Node.Limb to, float cur_second) { if (!IsArcValid(from, to)) { throw new ArgumentException(); } if (to == null) { throw new ArgumentException(); /*Limb nxt = new Limb(); for (int i = 0; i < Limb.PART_COUNT; ++i) { Part part = PartHelper.TransitionTo(from[i], null, cur_second); nxt[i] = part; } nxt.sanityCheck(); return nxt;*/ } else { Limb nxt = new Limb(); for (int i = 0; i < Limb.PART_COUNT; ++i) { Part part = PartHelper.TransitionTo(from[i], to[i], cur_second); nxt[i] = part; } if (to[Analyzer.Node.Limb.INDEX_EXTRA] == null) { nxt.extra = nxt.sub; } bool has_main = to.main != null; bool has_sub = to.sub != null; bool has_extra = to.extra != null; Fail fail = new Fail(nxt); if (has_main) { if (has_sub) { if (has_extra) { //main+sub+extra if (fail.main_sub) { throw new ArgumentException(); } if (fail.main_extra) { throw new ArgumentException(); } if (fail.sub_extra) { throw new ArgumentException(); } } else { //main+sub if (fail.main_sub) { throw new ArgumentException(); } if (fail.main_extra) { nxt.extra = nxt.sub; fail = new Fail(nxt); } if (fail.sub_extra) { nxt.extra = nxt.sub; fail = new Fail(nxt); } } } else if (has_extra) { //main+extra if (fail.main_sub) { nxt.sub = nxt.extra; fail = new Fail(nxt); } if (fail.main_extra) { throw new ArgumentException(); } if (fail.sub_extra) { nxt.sub = nxt.extra; fail = new Fail(nxt); } } else { //main if (fail.main_sub) { Panel n = Panel.CalculateBestBracketable(nxt.main.panel, nxt.sub.panel); Part src = nxt.sub; nxt.sub = new Part( Movement.Unknown, n, src.cur_second, cur_second, src.cur_moved_second == cur_second ? src.prv_moved_second : src.cur_moved_second ); fail = new Fail(nxt); } if (fail.main_extra) { nxt.extra = nxt.sub; fail = new Fail(nxt); } if (fail.sub_extra) { throw new ArgumentException(); } } } else if (has_sub) { if (has_extra) { //sub+extra if (fail.main_sub) { Panel n = Panel.CalculateBestBracketable(nxt.sub.panel, nxt.main.panel); Part src = nxt.main; nxt.main = new Part( Movement.Unknown, n, src.cur_second, cur_second, src.cur_moved_second == cur_second ? src.prv_moved_second : src.cur_moved_second ); fail = new Fail(nxt); } if (fail.main_extra) { Panel n = Panel.CalculateBestBracketable(nxt.extra.panel, nxt.main.panel); Part src = nxt.main; nxt.main = new Part( Movement.Unknown, n, src.cur_second, cur_second, src.cur_moved_second == cur_second ? src.prv_moved_second : src.cur_moved_second ); fail = new Fail(nxt); } if (fail.sub_extra) { throw new ArgumentException(); } } else { //sub if (fail.main_sub) { Panel n = Panel.CalculateBestBracketable(nxt.sub.panel, nxt.main.panel); Part src = nxt.main; nxt.main = new Part( Movement.Unknown, n, src.cur_second, cur_second, src.cur_moved_second == cur_second ? src.prv_moved_second : src.cur_moved_second ); fail = new Fail(nxt); } if (fail.main_extra) { throw new ArgumentException(); } if (fail.sub_extra) { nxt.extra = nxt.sub; fail = new Fail(nxt); } } } else if (has_extra) { //extra if (fail.main_sub) { throw new ArgumentException(); } if (fail.main_extra) { Panel n = Panel.CalculateBestBracketable(nxt.extra.panel, nxt.main.panel); Part src = nxt.main; nxt.main = new Part( Movement.Unknown, n, src.cur_second, cur_second, src.cur_moved_second == cur_second ? src.prv_moved_second : src.cur_moved_second ); fail = new Fail(nxt); } if (fail.sub_extra) { nxt.sub = nxt.extra; fail = new Fail(nxt); } } else { //NOTHING if (fail.main_sub) { throw new ArgumentException(); } if (fail.main_extra) { throw new ArgumentException(); } if (fail.sub_extra) { throw new ArgumentException(); } } if (fail.main_sub || fail.main_extra || fail.sub_extra) { throw new ArgumentException(); } nxt.sanityCheck(); return nxt; } }
/// <inheritdoc /> public ISessionFactory Open() { Fail.IfNull(this.factory, "You cannot reopen a database when it was disposed"); return(this.factory.Value); }
public static CreateScorePolicyCommand Create(string name, string description, List <ScoreRuleDto> scoreRules) { Fail.IfNullOrEmpty(name); Fail.IfNullOrEmpty(scoreRules); return(new CreateScorePolicyCommand(name, description, scoreRules)); }
public static string GetColumnName([NotNull] Member property) { Fail.IfArgumentNull(property, nameof(property)); return(property.Name + ForeignKeyColumnNameConvention.IdIdentifier); }
/// <inheritdoc /> public virtual void Dispose() { Fail.IfNull(ThreadStaticContextScope <T> .Sack, nameof(ThreadStaticContextScope <T> .Sack) + " is null"); ThreadStaticContextScope <T> .Sack.Value = default(T); ThreadStaticContextScope <T> .Sack = null; }
internal static Option <Dictionary <string, object> > CreateEntity <T, TDto, TCreateInterceptor>( this Option <ServiceMapping <T, TCreateInterceptor> > serviceMapping, Option <TDto> dto) where T : class, IEntity where TDto : class, IDto where TCreateInterceptor : ICreateInterceptor { try { return(serviceMapping.GetCreateParametersMapping(dto) .MapFlatten( x => { x.Args.PreValidation?.Invoke(x.Dto); x.Dto.Validate(); x.Args.PostValidation?.Invoke(x.Dto); var entity = x.Dto.ToEntity <T>(); AsyncHelper.RunSync(() => x.Args.PostMap?.Invoke(entity, x.Repository)); var result = x.Repository.Create(entity, x.Args.MessageIfExistFunc); AsyncHelper.RunSync(() => x.Args.PreSave?.Invoke(entity, x.Repository)); if (x.Args.PendingSave) { return result; } x.Uow.SaveChanges(); return result; })); } catch (ArgumentNullException ex) { return(Fail <Dictionary <string, object> > .Throw(ex)); } catch (ValidationException ex) { return(Fail <Dictionary <string, object> > .Throw(ex)); } catch (PreValidationException ex) { return(Fail <Dictionary <string, object> > .Throw(ex)); } catch (PostValidationException ex) { return(Fail <Dictionary <string, object> > .Throw(ex)); } catch (PostMapException ex) { return(Fail <Dictionary <string, object> > .Throw(ex)); } catch (PreSaveException ex) { return(Fail <Dictionary <string, object> > .Throw(ex)); } catch (ExistingEntityException <T> ex) { return(Fail <Dictionary <string, object> > .Throw(ex)); } #if NETSTANDARD2_0 catch (EfCoreDbUpdateException ex) { var message = ex.HumanizeKeyError(); return(Fail <Dictionary <string, object> > .Throw(new EfCoreDbUpdateException(message, ex))); } #endif #if NET471 catch (EfDbUpdateException ex) { var message = ex.HumanizeKeyError(); return(Fail <Dictionary <string, object> > .Throw(new EfDbUpdateException(message, ex))); } #endif catch (Exception ex) { return(Fail <Dictionary <string, object> > .Throw(ex)); } }
/// <summary> /// Sets the on failure delegate. /// </summary> /// <returns>The on failure delegate.</returns> /// <param name="onFail">On fail.</param> public Web SetOnFailureDelegate(Fail onFail) { this.OnFail = onFail; return this; }
internal static async Task <Option <Dictionary <string, object> > > CreateEntityAsync <T, TDto, TCreateInterceptor>( this Option <ServiceMapping <T, TCreateInterceptor> > serviceMapping, Option <TDto> dto, Option <CancellationToken> ctok) where T : class, IEntity where TDto : class, IDto where TCreateInterceptor : ICreateInterceptor { try { return(await serviceMapping.GetAsyncCreateParametersMapping(dto, ctok) .MapFlattenAsync( async x => { x.Args.PreValidation?.Invoke(x.Dto); await x.Dto.ValidateAsync(); x.Args.PostValidation?.Invoke(x.Dto); var entity = x.Dto.ToEntity <T>(); if (x.Args.PostMap != null) { await x.Args.PostMap.Invoke(entity, x.Repository); } var result = await x.Repository.CreateAsync(entity, x.Args.MessageIfExistFunc, x.Ctok); if (x.Args.PreSave != null) { await x.Args.PreSave.Invoke(entity, x.Repository); } if (x.Args.PendingSave) { return result; } await x.Uow.SaveChangesAsync(ctok); return result; })); } catch (ArgumentNullException ex) { return(Fail <Dictionary <string, object> > .Throw(ex)); } catch (ValidationException ex) { return(Fail <Dictionary <string, object> > .Throw(ex)); } catch (PreValidationException ex) { return(Fail <Dictionary <string, object> > .Throw(ex)); } catch (PostValidationException ex) { return(Fail <Dictionary <string, object> > .Throw(ex)); } catch (PostMapException ex) { return(Fail <Dictionary <string, object> > .Throw(ex)); } catch (PreSaveException ex) { return(Fail <Dictionary <string, object> > .Throw(ex)); } catch (ExistingEntityException <T> ex) { return(Fail <Dictionary <string, object> > .Throw(ex)); } #if NETSTANDARD2_0 catch (EfCoreDbUpdateException ex) { var message = ex.HumanizeKeyError(); return(Fail <Dictionary <string, object> > .Throw(new EfCoreDbUpdateException(message, ex))); } #endif #if NET471 catch (EfDbUpdateException ex) { var message = ex.HumanizeKeyError(); return(Fail <Dictionary <string, object> > .Throw(new EfDbUpdateException(message, ex))); } #endif catch (Exception ex) { return(Fail <Dictionary <string, object> > .Throw(ex)); } }
internal static async Task <Option <bool> > DeleteEntityAsync <T, TDto, TDeleteInterceptor>( this Option <ServiceMapping <T, TDeleteInterceptor> > serviceMapping, Option <TDto> criteria, Option <CancellationToken> ctok) where T : class, IEntity where TDto : class, IDto where TDeleteInterceptor : IDeleteInterceptor { try { return(await serviceMapping.GetAsyncDeleteParametersMapping(criteria, ctok) .MapFlattenAsync( async x => { var entityCriteria = x.Criteria.ToEntity <T>(); if (x.Args.PreDelete != null) { await x.Args.PreDelete.Invoke(entityCriteria, x.Repository); } var result = await x.Repository.DeleteAsync(entityCriteria, x.Ctok); if (x.Args.PreSave != null) { await x.Args.PreSave.Invoke(entityCriteria, x.Repository); } if (x.Args.PendingSave) { return result; } await x.Uow.SaveChangesAsync(x.Ctok); return result; })); } catch (ArgumentNullException ex) { return(Fail <bool> .Throw(ex)); } catch (KeyNotFoundException ex) { return(Fail <bool> .Throw(ex)); } catch (PreDeleteException ex) { return(Fail <bool> .Throw(ex)); } catch (PreSaveException ex) { return(Fail <bool> .Throw(ex)); } #if NETSTANDARD2_0 catch (EfCoreDbUpdateException ex) { return(Fail <bool> .Throw(ex)); } #endif #if NET471 catch (EfDbUpdateException ex) { return(Fail <bool> .Throw(ex)); } #endif catch (Exception ex) { return(Fail <bool> .Throw(ex)); } }
public String SendAndRead(String FileName, String OldFileName) { TcpClient tcpClient = new TcpClient(_Server, Convert.ToInt32(_Port)); String responseData = String.Empty; using (FileStream inputStream = File.OpenRead(FileName)) { using (NetworkStream outputStream = tcpClient.GetStream()) { using (BinaryWriter writer = new BinaryWriter(outputStream)) { bool CloseConnect = false; long lenght = inputStream.Length; long totalBytes = 0; int readBytes = 0; byte[] buffer = new byte[8192]; writer.Write(CloseConnect); writer.Write(SystemArgs.User.Login); writer.Write(OldFileName); writer.Write(SystemArgs.Path.GetFileName(FileName)); writer.Write(lenght); do { readBytes = inputStream.Read(buffer, 0, buffer.Length); outputStream.Write(buffer, 0, readBytes); totalBytes += readBytes; } while (tcpClient.Connected && totalBytes < lenght); Byte[] readingData = new Byte[256]; StringBuilder completeMessage = new StringBuilder(); int numberOfBytesRead = 0; do { numberOfBytesRead = outputStream.Read(readingData, 0, readingData.Length); completeMessage.AppendFormat("{0}", Encoding.UTF8.GetString(readingData, 0, numberOfBytesRead)); }while (outputStream.DataAvailable); responseData = completeMessage.ToString(); if (_NeedChecked) { if (AddDecodeSession(responseData.Replace(" ", ""))) { Load?.Invoke(_DecodeSession); } else { Fail?.Invoke(OldFileName); } } else if (responseData.Split('_').Length != 6) { Fail?.Invoke(OldFileName); } else { Rename?.Invoke(responseData, OldFileName); } } } } tcpClient.Close(); return(responseData); }
public void addFail(Fail fail) { status = "Suspicious"; fails.Add(fail); }
public static ChangeScoreCommand Create(int solutionId, int score) { Fail.If(solutionId <= 0); return(new ChangeScoreCommand(solutionId, score)); }
private async Task <List <SiloHandle> > getSilosToFail(Fail fail, int numOfFailures) { List <SiloHandle> failures = new List <SiloHandle>(); int count = 0, index = 0; // Figure out the primary directory partition and the silo hosting the ReminderTableGrain. bool usingReminderGrain = this.ClusterConfiguration.Globals.ReminderServiceType.Equals(GlobalConfiguration.ReminderServiceProviderType.ReminderTableGrain); IReminderTable tableGrain = this.GrainFactory.GetGrain <IReminderTableGrain>(Constants.ReminderTableGrainId); var tableGrainId = ((GrainReference)tableGrain).GrainId; SiloAddress reminderTableGrainPrimaryDirectoryAddress = (await TestUtils.GetDetailedGrainReport(this.HostedCluster.InternalGrainFactory, tableGrainId, this.HostedCluster.Primary)).PrimaryForGrain; // ask a detailed report from the directory partition owner, and get the actionvation addresses var addresses = (await TestUtils.GetDetailedGrainReport(this.HostedCluster.InternalGrainFactory, tableGrainId, this.HostedCluster.GetSiloForAddress(reminderTableGrainPrimaryDirectoryAddress))).LocalDirectoryActivationAddresses; ActivationAddress reminderGrainActivation = addresses.FirstOrDefault(); SortedList <int, SiloHandle> ids = new SortedList <int, SiloHandle>(); foreach (var siloHandle in this.HostedCluster.GetActiveSilos()) { SiloAddress siloAddress = siloHandle.SiloAddress; if (siloAddress.Equals(this.HostedCluster.Primary.SiloAddress)) { continue; } // Don't fail primary directory partition and the silo hosting the ReminderTableGrain. if (usingReminderGrain) { if (siloAddress.Equals(reminderTableGrainPrimaryDirectoryAddress) || siloAddress.Equals(reminderGrainActivation.Silo)) { continue; } } ids.Add(siloHandle.SiloAddress.GetConsistentHashCode(), siloHandle); } // we should not fail the primary! // we can't guarantee semantics of 'Fail' if it evalutes to the primary's address switch (fail) { case Fail.First: index = 0; while (count++ < numOfFailures) { while (failures.Contains(ids.Values[index])) { index++; } failures.Add(ids.Values[index]); } break; case Fail.Last: index = ids.Count - 1; while (count++ < numOfFailures) { while (failures.Contains(ids.Values[index])) { index--; } failures.Add(ids.Values[index]); } break; case Fail.Random: default: while (count++ < numOfFailures) { SiloHandle r = ids.Values[random.Next(ids.Count)]; while (failures.Contains(r)) { r = ids.Values[random.Next(ids.Count)]; } failures.Add(r); } break; } return(failures); }
private WindsorContainer GetContainerOrFail() { Fail.IfNull(this.container, $"{nameof(WindsorEngine)} is not started"); return(this.container); }
// throws jjtraveler.VisitFailure public virtual void testNonStopDownUp() { Identity downId = new Identity(); Identity upId = new Identity(); Fail stop = new Fail(); Logger expected = new Logger(); expected.log( new Event(downId, n3) ); expected.log( new Event(downId, n0) ); expected.log( new Event(upId, n0) ); expected.log( new Event(downId, n1) ); expected.log( new Event(upId, n1) ); expected.log( new Event(upId, n3) ); IVisitor visitor = new DownUp( logVisitor(downId), stop, logVisitor(upId) ); IVisitable nodeReturned = visitor.visit(n3); Assertion.AssertEquals(expected, logger); Assertion.AssertEquals(n3, nodeReturned); }
public void IfNotMidnightSuccess() { // ACT Fail.IfNotMidnight(DateTime.Today, "date should have no hour nor second"); }
private void FailIfThreadStaticContextScopeNotAvailable() { Fail.IfFalse(this.IsAvailable(), Violation.Of(nameof(ThreadStaticContextScope <T>) + " is not available")); }
public void IfNotMidnightSuccessWithNull() { // ACT Fail.IfNotMidnight(null, "date should have no hour nor second"); }
private List <SiloHandle> getSilosToFail(Fail fail, int numOfFailures) { List <SiloHandle> failures = new List <SiloHandle>(); int count = 0, index = 0; // Figure out the primary directory partition and the silo hosting the ReminderTableGrain. bool usingReminderGrain = this.HostedCluster.Primary.Silo.GlobalConfig.ReminderServiceType.Equals(GlobalConfiguration.ReminderServiceProviderType.ReminderTableGrain); IReminderTable tableGrain = GrainClient.GrainFactory.GetGrain <IReminderTableGrain>(Constants.ReminderTableGrainId); SiloAddress reminderTableGrainPrimaryDirectoryAddress = this.HostedCluster.Primary.Silo.LocalGrainDirectory.GetPrimaryForGrain(((GrainReference)tableGrain).GrainId); SiloHandle reminderTableGrainPrimaryDirectory = this.HostedCluster.GetActiveSilos().Where(sh => sh.Silo.SiloAddress.Equals(reminderTableGrainPrimaryDirectoryAddress)).FirstOrDefault(); AddressesAndTag addresses; bool res = reminderTableGrainPrimaryDirectory.Silo.LocalGrainDirectory.LocalLookup(((GrainReference)tableGrain).GrainId, out addresses); ActivationAddress reminderGrainActivation = addresses.Addresses.FirstOrDefault(); SortedList <int, SiloHandle> ids = new SortedList <int, SiloHandle>(); foreach (var siloHandle in this.HostedCluster.GetActiveSilos()) { SiloAddress siloAddress = siloHandle.Silo.SiloAddress; if (siloAddress.Equals(this.HostedCluster.Primary.Silo.SiloAddress)) { continue; } // Don't fail primary directory partition and the silo hosting the ReminderTableGrain. if (usingReminderGrain) { if (siloAddress.Equals(reminderTableGrainPrimaryDirectoryAddress) || siloAddress.Equals(reminderGrainActivation.Silo)) { continue; } } ids.Add(siloHandle.Silo.SiloAddress.GetConsistentHashCode(), siloHandle); } // we should not fail the primary! // we can't guarantee semantics of 'Fail' if it evalutes to the primary's address switch (fail) { case Fail.First: index = 0; while (count++ < numOfFailures) { while (failures.Contains(ids.Values[index])) { index++; } failures.Add(ids.Values[index]); } break; case Fail.Last: index = ids.Count - 1; while (count++ < numOfFailures) { while (failures.Contains(ids.Values[index])) { index--; } failures.Add(ids.Values[index]); } break; case Fail.Random: default: while (count++ < numOfFailures) { SiloHandle r = ids.Values[random.Next(ids.Count)]; while (failures.Contains(r)) { r = ids.Values[random.Next(ids.Count)]; } failures.Add(r); } break; } return(failures); }
public void IfDateEmptySuccess() { // ACT Fail.IfEmpty(DateTime.Today, nameof(DateTime.Today)); }
public static ContestsUsersQuery Create(int contestId) { Fail.If(contestId <= 0); return(new ContestsUsersQuery(contestId)); }
public static bool IsNotEmpty <T>([NotNull] this IEnumerable <T> collection) { Fail.IfNull(collection, nameof(collection)); return(collection.Any()); }
/// <summary> /// Creates the installer for specified <see cref="Library" />. /// </summary> public MvcControllerInstaller([NotNull] Library library) { Fail.IfArgumentNull(library, nameof(library)); this.library = library; }
protected override void NestedPackageFail(PackageResolverVisitor <IPackageInfo> newResolver) { base.NestedPackageFail(newResolver); Fail.AddRange(((LoggingPackageVisitor)newResolver).Fail); NotFound.AddRange(((LoggingPackageVisitor)newResolver).NotFound); }
public AutomappingConfiguration([NotNull] Type[] entities) { Fail.IfArgumentNull(entities, nameof(entities)); this.entities = entities; }
/// <summary> /// Allows you to provide your library dependencies - libraries used by your library. /// </summary> protected Library([NotNull] params Library[] dependencies) { Fail.IfArgumentNull(dependencies, nameof(dependencies)); this.Dependencies = dependencies; }
private async Task<List<SiloHandle>> getSilosToFail(Fail fail, int numOfFailures) { List<SiloHandle> failures = new List<SiloHandle>(); int count = 0, index = 0; // Figure out the primary directory partition and the silo hosting the ReminderTableGrain. bool usingReminderGrain = this.HostedCluster.Globals.ReminderServiceType.Equals(GlobalConfiguration.ReminderServiceProviderType.ReminderTableGrain); IReminderTable tableGrain = GrainClient.GrainFactory.GetGrain<IReminderTableGrain>(Constants.ReminderTableGrainId); var tableGrainId = ((GrainReference)tableGrain).GrainId; SiloAddress reminderTableGrainPrimaryDirectoryAddress = (await TestUtils.GetDetailedGrainReport(tableGrainId, this.HostedCluster.Primary)).PrimaryForGrain; // ask a detailed report from the directory partition owner, and get the actionvation addresses var addresses = (await TestUtils.GetDetailedGrainReport(tableGrainId, this.HostedCluster.GetSiloForAddress(reminderTableGrainPrimaryDirectoryAddress))).LocalDirectoryActivationAddresses; ActivationAddress reminderGrainActivation = addresses.FirstOrDefault(); SortedList<int, SiloHandle> ids = new SortedList<int, SiloHandle>(); foreach (var siloHandle in this.HostedCluster.GetActiveSilos()) { SiloAddress siloAddress = siloHandle.SiloAddress; if (siloAddress.Equals(this.HostedCluster.Primary.SiloAddress)) { continue; } // Don't fail primary directory partition and the silo hosting the ReminderTableGrain. if (usingReminderGrain) { if (siloAddress.Equals(reminderTableGrainPrimaryDirectoryAddress) || siloAddress.Equals(reminderGrainActivation.Silo)) { continue; } } ids.Add(siloHandle.SiloAddress.GetConsistentHashCode(), siloHandle); } // we should not fail the primary! // we can't guarantee semantics of 'Fail' if it evalutes to the primary's address switch (fail) { case Fail.First: index = 0; while (count++ < numOfFailures) { while (failures.Contains(ids.Values[index])) { index++; } failures.Add(ids.Values[index]); } break; case Fail.Last: index = ids.Count - 1; while (count++ < numOfFailures) { while (failures.Contains(ids.Values[index])) { index--; } failures.Add(ids.Values[index]); } break; case Fail.Random: default: while (count++ < numOfFailures) { SiloHandle r = ids.Values[random.Next(ids.Count)]; while (failures.Contains(r)) { r = ids.Values[random.Next(ids.Count)]; } failures.Add(r); } break; } return failures; }
/// <inheritdoc /> public bool Equals(Library other) { Fail.IfArgumentNull(other, nameof(other)); return(this.GetAssembly() == other.GetAssembly()); }
public static ContestEndCommand Create(int contestId) { Fail.If(contestId <= 0); return(new ContestEndCommand(contestId)); }
private List<SiloHandle> getSilosToFail(Fail fail, int numOfFailures) { List<SiloHandle> failures = new List<SiloHandle>(); int count = 0, index = 0; // Figure out the primary directory partition and the silo hosting the ReminderTableGrain. bool usingReminderGrain = Primary.Silo.GlobalConfig.ReminderServiceType.Equals(GlobalConfiguration.ReminderServiceProviderType.ReminderTableGrain); IReminderTable tableGrain = GrainClient.GrainFactory.GetGrain<IReminderTableGrain>(Constants.ReminderTableGrainId); SiloAddress reminderTableGrainPrimaryDirectoryAddress = Primary.Silo.LocalGrainDirectory.GetPrimaryForGrain(((GrainReference) tableGrain).GrainId); SiloHandle reminderTableGrainPrimaryDirectory = GetActiveSilos().Where(sh => sh.Silo.SiloAddress.Equals(reminderTableGrainPrimaryDirectoryAddress)).FirstOrDefault(); List<ActivationAddress> addresses = null; bool res = reminderTableGrainPrimaryDirectory.Silo.LocalGrainDirectory.LocalLookup(((GrainReference)tableGrain).GrainId, out addresses); ActivationAddress reminderGrainActivation = addresses.FirstOrDefault(); SortedList<int, SiloHandle> ids = new SortedList<int, SiloHandle>(); foreach (var siloHandle in GetActiveSilos()) { SiloAddress siloAddress = siloHandle.Silo.SiloAddress; if (siloAddress.Equals(Primary.Silo.SiloAddress)) { continue; } // Don't fail primary directory partition and the silo hosting the ReminderTableGrain. if (usingReminderGrain) { if (siloAddress.Equals(reminderTableGrainPrimaryDirectoryAddress) || siloAddress.Equals(reminderGrainActivation.Silo)) { continue; } } ids.Add(siloHandle.Silo.SiloAddress.GetConsistentHashCode(), siloHandle); } // we should not fail the primary! // we can't guarantee semantics of 'Fail' if it evalutes to the primary's address switch (fail) { case Fail.First: index = 0; while (count++ < numOfFailures) { while (failures.Contains(ids.Values[index])) { index++; } failures.Add(ids.Values[index]); } break; case Fail.Last: index = ids.Count - 1; while (count++ < numOfFailures) { while (failures.Contains(ids.Values[index])) { index--; } failures.Add(ids.Values[index]); } break; case Fail.Random: default: while (count++ < numOfFailures) { SiloHandle r = ids.Values[random.Next(ids.Count)]; while (failures.Contains(r)) { r = ids.Values[random.Next(ids.Count)]; } failures.Add(r); } break; } return failures; }
public CompilationMockQueryHandler Returns(CompilationQueryResult result) { Fail.IfNull(_onQuery); _expectedBehaviors[_onQuery] = result; return(this); }
public static List<Limb> TransitionToV2 (Limb from, Analyzer.Node.Limb to, float cur_second) { if (!IsArcValid(from, to)) { throw new ArgumentException(); } if (to == null) { throw new ArgumentException(); } List<Limb> result = new List<Limb>(); Limb nxt = new Limb(); for (int i = 0; i < Limb.PART_COUNT; ++i) { Part part = PartHelper.TransitionTo(from[i], to[i], cur_second); nxt[i] = part; } if (to[Analyzer.Node.Limb.INDEX_EXTRA] == null) { nxt.extra = nxt.sub; } bool has_main = to.main != null; bool has_sub = to.sub != null; bool has_extra = to.extra != null; Fail fail = new Fail(nxt); if (has_main) { if (has_sub) { if (has_extra) { //main+sub+extra if (fail.main_sub) { //throw new ArgumentException(); } if (fail.main_extra) { //throw new ArgumentException(); } if (fail.sub_extra) { //throw new ArgumentException(); } } else { //main+sub if (fail.main_sub) { //throw new ArgumentException(); } if (fail.main_extra) { nxt.extra = nxt.sub; fail = new Fail(nxt); } if (fail.sub_extra) { nxt.extra = nxt.sub; fail = new Fail(nxt); } } } else if (has_extra) { //main+extra if (fail.main_sub) { nxt.sub = nxt.extra; fail = new Fail(nxt); } if (fail.main_extra) { //throw new ArgumentException(); } if (fail.sub_extra) { nxt.sub = nxt.extra; fail = new Fail(nxt); } } else { //main if (fail.main_sub) { List<Panel> neighbours = Panel.Neighbours_1D[nxt.main.panel.index]; foreach (Panel n in neighbours) { Limb copy = Limb.DirectCopy(nxt); Part src = copy.sub; copy.sub = new Part( Movement.Unknown, n, src.cur_second, cur_second, src.cur_moved_second == cur_second ? src.prv_moved_second : src.cur_moved_second ); Fail copy_fail = new Fail(copy); if (copy_fail.main_extra) { copy.extra = copy.sub; } AddIfValid(result, copy); } } if (fail.main_extra) { nxt.extra = nxt.sub; fail = new Fail(nxt); } if (fail.sub_extra) { //throw new ArgumentException(); } } } else if (has_sub) { if (has_extra) { //sub+extra if (fail.main_sub) { List<Panel> neighbours = Panel.Neighbours_1D[nxt.sub.panel.index]; foreach (Panel n in neighbours) { Limb copy = Limb.DirectCopy(nxt); Part src = copy.main; copy.main = new Part( Movement.Unknown, n, src.cur_second, cur_second, src.cur_moved_second == cur_second ? src.prv_moved_second : src.cur_moved_second ); Fail copy_fail = new Fail(copy); if (copy_fail.main_extra) { List<Panel> neighbours_2 = Panel.Neighbours_1D[nxt.extra.panel.index]; foreach (Panel n_2 in neighbours_2) { Limb copy_2 = Limb.DirectCopy(copy); Part src_2 = copy_2.main; copy_2.main = new Part( Movement.Unknown, n_2, src_2.cur_second, cur_second, src_2.cur_moved_second == cur_second ? src_2.prv_moved_second : src_2.cur_moved_second ); AddIfValid(result, copy_2); } } AddIfValid(result, copy); } } if (fail.main_extra) { List<Panel> neighbours_2 = Panel.Neighbours_1D[nxt.extra.panel.index]; foreach (Panel n_2 in neighbours_2) { Limb copy_2 = Limb.DirectCopy(nxt); Part src_2 = copy_2.main; copy_2.main = new Part( Movement.Unknown, n_2, src_2.cur_second, cur_second, src_2.cur_moved_second == cur_second ? src_2.prv_moved_second : src_2.cur_moved_second ); AddIfValid(result, copy_2); } } if (fail.sub_extra) { //throw new ArgumentException(); } } else { //sub if (fail.main_sub) { List<Panel> neighbours = Panel.Neighbours_1D[nxt.sub.panel.index]; foreach (Panel n in neighbours) { Limb copy = Limb.DirectCopy(nxt); Part src = copy.main; copy.main = new Part( Movement.Unknown, n, src.cur_second, cur_second, src.cur_moved_second == cur_second ? src.prv_moved_second : src.cur_moved_second ); Fail copy_fail = new Fail(copy); if (copy_fail.main_extra) { //do nothing } if (copy_fail.sub_extra) { copy.extra = copy.sub; } AddIfValid(result, copy); } } if (fail.main_extra) { //throw new ArgumentException(); } if (fail.sub_extra) { nxt.extra = nxt.sub; } } } else if (has_extra) { //extra if (fail.main_sub) { //throw new ArgumentException(); } if (fail.main_extra) { List<Panel> neighbours = Panel.Neighbours_1D[nxt.extra.panel.index]; foreach (Panel n in neighbours) { Limb copy = Limb.DirectCopy(nxt); Part src = copy.main; copy.main = new Part( Movement.Unknown, n, src.cur_second, cur_second, src.cur_moved_second == cur_second ? src.prv_moved_second : src.cur_moved_second ); Fail copy_fail = new Fail(copy); if (copy_fail.sub_extra) { copy.sub = copy.extra; } AddIfValid(result, copy); } } if (fail.sub_extra) { nxt.sub = nxt.extra; } } else { //NOTHING if (fail.main_sub) { //throw new ArgumentException(); } if (fail.main_extra) { //throw new ArgumentException(); } if (fail.sub_extra) { //throw new ArgumentException(); } } AddIfValid(result, nxt); return result; }
/// <inheritdoc /> public void Store(T value) { Fail.IfArgumentNull(value, nameof(value)); StaticContextStorage <T> .storedValue = value; }
public void IfEqualSuccess() { // ACT Fail.IfEqual("s1", "s2", "values are equal and shouldn't be"); }
private HttpResponse GetResponse() { Fail.IfFalse(this.IsAvailable(), Violation.Of("HttpContext.Current.Response is not available.")); return(HttpContext.Current.Response); }
private static void AddIfValid (List<Limb> list, Limb item) { Fail fail = new Fail(item); if (fail.main_sub || fail.main_extra || fail.sub_extra) { return; } item.sanityCheck(); list.Add(item); }