protected override long RunResolve(Stopwatch sw, ITestCase testCase, object container, int testCasesCount, RegistrationKind registrationKind) { try { if (registrationKind == RegistrationKind.PerThread) { if (testCase is PerThreadTestCaseD) { throw new OutOfMemoryException("Process takes more than 20 minutes!"); } sw.Start(); using (((ServiceContainer)container).BeginScope()) { testCase.Resolve(container, testCasesCount); } sw.Stop(); return(sw.ElapsedMilliseconds); } return(base.RunResolve(sw, testCase, container, testCasesCount, registrationKind)); } catch (OutOfMemoryException) { return(-1); } }
// ----------------------------------------------------------------------- // Register something with our PM given the specified information. // The data passed in is stored directly in our map so the assumption // is that we are now owners. // ie. don't delete this data object elsewhere! // ----------------------------------------------------------------------- private int RegisterWithPM(String name, String units, String description, RegistrationKind regKind, String sDDML) //,Packable* data); { String ddml = sDDML; if (units != "") { addAttributeToXML(ddml, "unit=\"" + units + "\""); } if (description != "") { addAttributeToXML(ddml, "description=\"" + description + "\""); } // Add new object to our map. String fullRegName = name + regKind.ToString(); Reg reg = new Reg(); reg.data = new TDDMLValue(sDDML, ""); reg.kind = regKind; reg.ddml = ddml; reg.regID = nextID(); regNames.Add(fullRegName, reg); SendRegisterMsg(name, ddml, reg.regID, (int)regKind, 0); return(reg.regID); }
public object Register(object container, RegistrationKind registrationKind) { container = _registration.BeforeRegisterCallback(container, registrationKind); RegisterClasses(container); return(_registration.AfterRegisterCallback(container, registrationKind)); }
private void AppendResults(Dictionary <string, IEnumerable <FinalTestResult> > results, string testCaseName, RegistrationKind registrationKind, StringBuilder sb) { foreach (var result in results) { AppendResult(testCaseName, registrationKind, sb, result); } }
protected virtual object RunRegister(Stopwatch sw, ITestCase testCase, object container, RegistrationKind registrationKind) { sw.Start(); var newContainer = testCase.Register(container, registrationKind); sw.Stop(); return(newContainer); }
public void SetRegistrationKind(RegistrationKind kind, string city, string code) { if (kind == RegistrationKind.RCS) { Identifier = $"{kind:G} {city.Trim()} {Siret.Substring(0, 9)} "; } if (kind == RegistrationKind.RM) { Identifier = $"{kind:G} {Siret.Substring(0, 9)} {code.Trim()}"; } }
protected override long RunResolve(Stopwatch sw, ITestCase testCase, object container, int testCasesCount, RegistrationKind registrationKind) { try { return(base.RunResolve(sw, testCase, container, testCasesCount, registrationKind)); } catch (OutOfMemoryException) { return(-1); } }
/// <summary> /// /// </summary> /// <param name="dllName"></param> /// <returns></returns> String getDescription(String dllName) { StringBuilder returnString = new StringBuilder(); try { returnString.Append("<describecomp>\n"); returnString.Append("<executable>" + dllName + "</executable>\n"); returnString.Append("<class>" + name + "</class>\n"); returnString.Append("<version>1.0</version>\n"); returnString.Append("<author>APSRU</author>\n"); foreach (KeyValuePair <String, Reg> reg in regNames) { RegistrationKind Kind = reg.Value.kind; if (Kind == RegistrationKind.respondToGetReg) { returnString.Append(getPropertyDescription(reg, "read")); } else if (Kind == RegistrationKind.respondToSetReg) { returnString.Append(getPropertyDescription(reg, "write")); } else if (Kind == RegistrationKind.respondToGetSetReg) { returnString.Append(getPropertyDescription(reg, "both")); } else if (Kind == RegistrationKind.respondToEventReg) { returnString.Append(getEventDescription(reg, "subscribed")); } else if (Kind == RegistrationKind.eventReg) { returnString.Append(getEventDescription(reg, "published")); } else if (Kind == RegistrationKind.getReg) { returnString.Append(" <driver name=\""); returnString.Append(getRegName(reg)); returnString.Append("\">\n"); returnString.Append(reg.Value.ddml); returnString.Append("\n</driver>\n"); } } } catch (Exception err) { returnString.Append("<ERROR>" + err.Message + "</ERROR>\n"); } returnString.Append("</describecomp>\n"); return(returnString.ToString()); }
private void AppendResult(string testCaseName, RegistrationKind registrationKind, StringBuilder sb, KeyValuePair <string, IEnumerable <FinalTestResult> > result) { var currentValues = GetCurrentValues(testCaseName, registrationKind, result); sb.Append(result.Key); foreach (var currentValue in currentValues.OrderBy(r => r.TestCasesCount)) { sb.Append(GetValuesAsText(currentValue)); } sb.Append(" \\\\ \\hline"); sb.AppendLine(); }
/// <summary> /// Return a registration id for the specified name. 0 if not found. /// </summary> /// <param name="name"></param> /// <param name="regKind"></param> /// <returns>0 if not found</returns> private int nameToRegistrationID(String name, RegistrationKind regKind) { String FullRegName = name + regKind.ToString(); if (regNames.ContainsKey(FullRegName)) { return(regNames[FullRegName].regID); } else { return(0); } }
public override object BeforeRegisterCallback(object container, RegistrationKind registrationKind) { if (registrationKind == RegistrationKind.PerThread) { var c = (Container)container; c.Options.DefaultScopedLifestyle = new LifetimeScopeLifestyle(); return(c); } return(base.BeforeRegisterCallback(container, registrationKind)); }
/* bool read(const std::string& name, Convertable* value, bool optional); * bool read(const std::string& name, std::vector<Convertable*> values, bool optional); * * void publish(const std::string& name, Packable* data); * void subscribe(const std::string& eventName, Packable* handler); * void query(const std::string& pattern, std::vector<QueryMatch>& matches); * * void setSearchOrder(const std::vector<std::string> &list) {simSectionsToSearch = list;}; * void getSearchOrder(std::vector<std::string> &list) {list = simSectionsToSearch;}; * bool readFiltered(const std::string& filterName, std::vector<std::string> &values); * bool readAll(std::vector<std::string> &names, std::vector<std::string> &values); * bool readScripts(std::map<std::string, std::string> &scripts); */ // ----------------------------------------------------------------------- /// <summary> /// Export a variable. The variable passed in is stored directly /// in our map so the assumption is that we are now owners. /// ie. don't delete this data object elsewhere! /// </summary> /// <param name="name"></param> /// <param name="units"></param> /// <param name="description"></param> /// <param name="writable"></param> // ----------------------------------------------------------------------- public void expose(String name, String units, String description, Boolean writable, String sDDML) //,Packable* variable); { RegistrationKind kind = RegistrationKind.respondToGetReg; if (writable) { kind = RegistrationKind.respondToGetSetReg; } if (nameToRegistrationID(name, RegistrationKind.respondToGetReg) == 0) { RegisterWithPM(name, units, description, kind, sDDML); } }
protected virtual long RunResolve(Stopwatch sw, ITestCase testCase, object container, int testCasesCount, RegistrationKind registrationKind) { try { sw.Start(); testCase.Resolve(container, testCasesCount); sw.Stop(); return(sw.ElapsedMilliseconds); } catch (OutOfMemoryException) { return(-1); } }
public TestResult RunTest(int count, string testCaseName, RegistrationKind registrationKind) { var testResult = new TestResult { TestCaseName = testCaseName, RegistrationKind = registrationKind, TestCasesCount = count }; var sw = new Stopwatch(); var testCase = GetTestCase(testCaseName, registrationKind); var container = RunRegister(sw, testCase, GetContainer(registrationKind), registrationKind); testResult.RegisterTime = sw.ElapsedMilliseconds; sw.Reset(); testResult.ResolveTime = RunResolve(sw, testCase, container, count, registrationKind); RunDispose(container); return(testResult); }
protected override long RunResolve(Stopwatch sw, ITestCase testCase, object container, int testCasesCount, RegistrationKind registrationKind) { try { if (registrationKind == RegistrationKind.PerThread) { sw.Start(); using (var scope = ((DependencyInjectionContainer)container).BeginLifetimeScope()) { testCase.Resolve(scope, testCasesCount); } sw.Stop(); return(sw.ElapsedMilliseconds); } return(base.RunResolve(sw, testCase, container, testCasesCount, registrationKind)); } catch (OutOfMemoryException) { return(-1); } }
protected override object GetContainer(RegistrationKind registrationKind) { return(new DependencyInjectionContainer()); }
private string RunTests(string containerName, RegistrationKind registrationKind, string testCase, int testsCount) { return(ProcessHelper.StartProcess(_processPath, $"{containerName} -r {(int)registrationKind} -t {testCase} -c {testsCount}")); }
protected abstract object GetContainer(RegistrationKind registrationKind);
protected abstract string GetRegistrationKindColumnNameText(RegistrationKind registrationKind);
internal async Task StartAsync(string configContent, RegistrationKind regKind) { Logger.LogInfo("Framework starting..."); // Load and validate configuration data var config = new Configuration(); config.Load(configContent); _config = config; var clientId = config.DefaultClientId; Organization = config.OAuth.Client.Organization; Name = config.OAuth.Client.ClientName; DetailedDescription = config.OAuth.Client.Description; Identifier = config.DefaultClientId.Id; Environment = config.DefaultClientId.Environment; RegisteredBy = config.DefaultClientId.RegisteredBy; Scope = new List <string>(config.DefaultClientId.Scope.Split(' ').Where(s => !string.IsNullOrWhiteSpace(s))).AsReadOnly(); ScopeAsString = config.DefaultClientId.Scope; Status = config.DefaultClientId.Status; RedirectUri = config.DefaultClientId.RedirectUri; // Load device and any previous registration info. await MASDevice.InitializeAsync(config); // Authorization providers not supported yet //var response = await MAGRequests.GetAuthorizationProviders(_config, Device); // Load client access if client registration is requested if (MAS.RegistrationKind == RegistrationKind.Client) { Client = await MASUser.InitializeAsync(config, MASDevice.Current, true); } // Load user and any previous access token or idtoken info await MASUser.InitializeAsync(config, MASDevice.Current, false); if (!MASDevice.Current.IsRegistered) { switch (regKind) { case RegistrationKind.Client: if (!config.HasScope(ScopeNames.MssoClientRegister)) { ErrorFactory.ThrowError(ErrorCode.DeviceRegistrationAttemptedWithUnregisteredScope); } await MASDevice.Current.RegisterWithClientAsync(); // Create a device anonymous user var clientUser = new MASUser(_config, MASDevice.Current); await clientUser.LoginAnonymouslyAsync(); Client = clientUser; break; case RegistrationKind.User: // Ask for login with user device registration LoginRequested?.Invoke(null, EventArgs.Empty); break; default: ErrorFactory.ThrowError(ErrorCode.DeviceRegistrationAttemptedWithUnregisteredScope); break; } } Logger.LogInfo("Framework started"); }
protected ITestCase GetTestCase(string testCase, RegistrationKind registrationKind) { switch (testCase) { case TestCaseName.A: switch (registrationKind) { case RegistrationKind.Singleton: return(new SingletonTestCaseA(GetRegistration(), GetResolving())); case RegistrationKind.Transient: return(new TransientTestCaseA(GetRegistration(), GetResolving())); case RegistrationKind.TransientSingleton: return(new TransientSingletonTestCaseA(GetRegistration(), GetResolving())); case RegistrationKind.PerThread: return(new PerThreadTestCaseA(GetRegistration(), GetResolving())); case RegistrationKind.FactoryMethod: return(new FactoryMethodTestCaseA(GetRegistration(), GetResolving())); default: throw new ArgumentOutOfRangeException(nameof(registrationKind), registrationKind, null); } case TestCaseName.B: switch (registrationKind) { case RegistrationKind.Singleton: return(new SingletonTestCaseB(GetRegistration(), GetResolving())); case RegistrationKind.Transient: return(new TransientTestCaseB(GetRegistration(), GetResolving())); case RegistrationKind.TransientSingleton: return(new TransientSingletonTestCaseB(GetRegistration(), GetResolving())); case RegistrationKind.PerThread: return(new PerThreadTestCaseB(GetRegistration(), GetResolving())); case RegistrationKind.FactoryMethod: return(new FactoryMethodTestCaseB(GetRegistration(), GetResolving())); default: throw new ArgumentOutOfRangeException(nameof(registrationKind), registrationKind, null); } case TestCaseName.C: switch (registrationKind) { case RegistrationKind.Singleton: return(new SingletonTestCaseC(GetRegistration(), GetResolving())); case RegistrationKind.Transient: return(new TransientTestCaseC(GetRegistration(), GetResolving())); case RegistrationKind.TransientSingleton: return(new TransientSingletonTestCaseC(GetRegistration(), GetResolving())); case RegistrationKind.PerThread: return(new PerThreadTestCaseC(GetRegistration(), GetResolving())); case RegistrationKind.FactoryMethod: return(new FactoryMethodTestCaseC(GetRegistration(), GetResolving())); default: throw new ArgumentOutOfRangeException(nameof(registrationKind), registrationKind, null); } case TestCaseName.D: switch (registrationKind) { case RegistrationKind.Singleton: return(new SingletonTestCaseD(GetRegistration(), GetResolving())); case RegistrationKind.Transient: return(new TransientTestCaseD(GetRegistration(), GetResolving())); case RegistrationKind.TransientSingleton: return(new TransientSingletonTestCaseD(GetRegistration(), GetResolving())); case RegistrationKind.PerThread: return(new PerThreadTestCaseD(GetRegistration(), GetResolving())); case RegistrationKind.FactoryMethod: return(new FactoryMethodTestCaseD(GetRegistration(), GetResolving())); default: throw new ArgumentOutOfRangeException(nameof(registrationKind), registrationKind, null); } default: throw new ArgumentOutOfRangeException(nameof(registrationKind), registrationKind, null); } }
protected override string GetRegistrationKindColumnNameText(RegistrationKind registrationKind) { return ($"{registrationKind};{registrationKind};{registrationKind};{registrationKind};{registrationKind};{registrationKind};"); }
public virtual object BeforeRegisterCallback(object container, RegistrationKind registrationKind) { return(container); }
private static IEnumerable <FinalTestResult> GetCurrentValues(string testCaseName, RegistrationKind registrationKind, KeyValuePair <string, IEnumerable <FinalTestResult> > result) { return(result.Value.Where(r => r.TestCaseName == testCaseName && r.RegistrationKind == registrationKind)); }
private static TestResult RunPerformanceTests(IPerformanceTest performanceTest, int count, string testCase, RegistrationKind registrationKind) { WarmUpPerformanceTest(performanceTest, testCase, registrationKind); return(performanceTest.RunTest(count, testCase, registrationKind)); }
private static void WarmUpPerformanceTest(IPerformanceTest performanceTest, string testCase, RegistrationKind registrationKind) { performanceTest.RunTest(1, testCase, registrationKind); }
public override object AfterRegisterCallback(object container, RegistrationKind registrationKind) { return(((ContainerBuilder)container).Build()); }
protected override object GetContainer(RegistrationKind registrationKind) { return(registrationKind == RegistrationKind.PerThread ? new Container(scopeContext: new ThreadScopeContext()) : new Container()); }
protected override object GetContainer(RegistrationKind registrationKind) { return(new Container()); }
protected override object GetContainer(RegistrationKind registrationKind) { return(new StandardKernel()); }