private void Add(SpecificationBase spec) { if (spec != null) { this.registry.Add(spec); } }
public override void Initialize(SpecificationBase spec) { //initialize the ModelCheckingOptions base.Initialize(spec); Specification Spec = spec as Specification; ReachableStateCondition = Spec.DeclarationDatabase[ReachableStateLabel]; List <string> varList = Process.GetGlobalVariables(); varList.AddRange(ReachableStateCondition.GetVars()); varList.AddRange(ConstraintCondition.GetVars()); Valuation GlobalEnv = Spec.SpecValuation.GetVariableChannelClone(varList, Process.GetChannels()); //Initialize InitialStep InitialStep = new Configuration(Process, Constants.INITIAL_EVENT, null, GlobalEnv, false); MustAbstract = Process.MustBeAbstracted(); if (MustAbstract) { throw new ParsingException( "Process " + StartingProcess + " has infinite states and therefore can not be used to assert reachability with MIN/MAX constraints!", AssertToken); } }
public SpecificationBase GetSpecification() { if (_resolvedSpecificationBase == null) { //Lazy Load Specification if (String.IsNullOrEmpty(_specificationType)) { //No Specification specified, so get Default Specification For Type from Validation Catalog _resolvedSpecificationBase = ValidationCatalog.SpecificationContainer.TryGetSpecification(GetTypeToValidate()); } else { //Get Specification from Type //Create type from string var specType = System.Type.GetType(_specificationType); if (specType == null) { //Type creation failed return(null); } else { //Query the Validation Catalog from the specification that matches type in the Catalog _resolvedSpecificationBase = ValidationCatalog.SpecificationContainer.GetAllSpecifications().Where( x => x.GetType() == specType).FirstOrDefault(); } } } return(_resolvedSpecificationBase); }
public override void Initialize(SpecificationBase spec) { //initialize the ModelCheckingOptions base.Initialize(spec); Assertion.Initialize(this, ImplementationProcess, SpecificationProcess, spec); }
public SpecificationBase GetSpecification() { if (_resolvedSpecificationBase == null) { //Lazy Load Specification if (String.IsNullOrEmpty(_specificationType)) { //No Specification specified, so get Default Specification For Type from Validation Catalog _resolvedSpecificationBase = ValidationCatalog.SpecificationContainer.TryGetSpecification(GetTypeToValidate()); } else { //Get Specification from Type //Create type from string var specType = System.Type.GetType(_specificationType); if (specType == null) { //Type creation failed return null; } else { //Query the Validation Catalog from the specification that matches type in the Catalog _resolvedSpecificationBase = ValidationCatalog.SpecificationContainer.GetAllSpecifications().Where( x => x.GetType() == specType).FirstOrDefault(); } } } return _resolvedSpecificationBase; }
public DiagnosisResult executeAssertion(SpecificationBase spec, String assertionName) { AssertionBase assertion = spec.AssertionDatabase[assertionName]; AssertionVerifier verifier = new AssertionVerifier(assertion, 1, 0); return(verifier.Run()); }
public void DisplayTree(SpecificationBase Spec) { try { Specification = Spec; foreach (TreeNode node in TreeView_Model.Nodes) { node.Nodes.Clear(); } if (Spec != null) { foreach (KeyValuePair <string, Declaration> pair in Spec.DeclaritionTable) { try { TreeNode node = this.TreeView_Model.Nodes[pair.Value.DeclarationType.ToString()].Nodes.Add(pair.Key); node.Tag = pair.Value.DeclarationToken; } catch (Exception) { } } TreeView_Model.ExpandAll(); } } catch (Exception) { } }
public List <VerifyResult> SyncVerify(List <ArchDesignConfig> designSet) { PATUtil util = new PATUtil(); // generate CSP Code resultSet = new List <VerifyResult>(); List <ThreadedVerificationExecuter <VerifyResult> > threadsList = new List <ThreadedVerificationExecuter <VerifyResult> >(); ThreadedVerificationExecuter <VerifyResult> thread; PAT.CSP.ModuleFacade modulebase = new PAT.CSP.ModuleFacade(); foreach (ArchDesignConfig designConfig in designSet) { VerifyAsset verifyAsset = util.GenerateAsset(designConfig.matrix); SpecificationBase specbase = modulebase.ParseSpecification(verifyAsset.CSPCode, string.Empty, string.Empty); thread = new ThreadedVerificationExecuter <VerifyResult>(collectVerifyResult, verifyAsset, specbase); threadsList.Add(thread); thread.Start(); } while (resultSet.Count < designSet.Count) { System.Diagnostics.Debug.WriteLine("Waiting for result " + resultSet.Count); } return(resultSet); }
public void executeVerification(VerifyAsset verifyAsset, SpecificationBase specbase) { //initialize CSP module with CSP Code PATUtil util = new PATUtil(); Stopwatch sw = new Stopwatch(); sw.Start(); // run assertions and gather results ConcurrentBag <DiagnosisResult> results = new ConcurrentBag <DiagnosisResult>(); foreach (String assertionName in verifyAsset.deadloopCheck) { results.Add(util.executeAssertion(specbase, assertionName)); } foreach (String assertionName in verifyAsset.livelockCheck) { results.Add(util.executeAssertion(specbase, assertionName)); } sw.Stop(); VerifyResult verResult = new VerifyResult(); verResult.elapseTime = sw.ElapsedMilliseconds; verResult.diagnosisList = results; System.Diagnostics.Debug.WriteLine("Total Result" + results.Count); T stuffReturned = (T)Convert.ChangeType(verResult, typeof(T)); callback(stuffReturned); }
public void executeAssertion(SpecificationBase spec, String assertionName) { AssertionBase assertion = spec.AssertionDatabase[assertionName]; AssertionVerifier verifier = new AssertionVerifier(assertion, 1, 0); T stuffReturned = (T)Convert.ChangeType(verifier.Run(), typeof(T)); callback(stuffReturned); }
protected ISpecification <TEntity> InitializeSpecification(ISpecification <TEntity> specification) { if (specification == null) { specification = new SpecificationBase <TEntity>(); } return(specification); }
public void DoubleNotSpecificationTrueTest(string name) { var spec1 = new SpecificationBase <SimpleTestObject>(t => t.Name == name); var spec = !!spec1; Assert.True(spec.IsSatisfiedBy(SimpleTestObject.Create_For_Test_Where_Count_Is_Five_And_Name_Is_Name())); }
//todo properly handle deletable and expirable public void Remove(SpecificationBase <T> specification) { if (specification == null) { throw new ArgumentNullException(nameof(specification)); } _dbSet.RemoveRange(_dbSet.Where(specification.ToExpression()) .Select(x => x)); }
// handle translation public IEnumerable <T> Find(SpecificationBase <T> spec) { return(EnableTranslation && _lexiconDictionary.IsMultiLingualEntity(typeof(T)) ? _lexiconDictionary.Translate( ApplySpecification(spec) .ToList(), _userContext?.Identity.LanguageIsoCode) : ApplySpecification(spec) .ToList()); }
//private string GetOption() //{ // string option = ""; // option += MenuButton_EnableSimplificationOfTheFormula.Checked ? "" : "l"; // option += MenuButton_EnableOntheflyAutomataSimplification.Checked ? "" : "o"; // option += MenuButton_EnableAPosterioriAutomataSimplification.Checked ? "" : "p"; // option += MenuButton_EnableStronglyConnectedComponentsSimplification.Checked ? "" : "c"; // option += MenuButton_EnableTrickingInAcceptingConditions.Checked ? "" : "a"; // return option; //} private SpecificationBase parseSpecification() { SpecificationBase spec = null; do { if (mTabItem == null || mTabItem.Text.Trim() == "") { DevLog.e(TAG, "mTabItem is null"); break; } // DisableAllControls(); try { string moduleName = mTabItem.ModuleName; if (LoadModule(moduleName)) { //string option = GetOption(); Stopwatch t = new Stopwatch(); // DisableAllControls(); disableAllControls(); t.Start(); spec = mModule.ParseSpecification(mTabItem.Text, "", mTabItem.FileName); t.Stop(); if (spec != null) { mTabItem.Specification = spec; if (spec.Errors.Count > 0) { string key = ""; foreach (KeyValuePair <string, ParsingException> pair in spec.Errors) { key = pair.Key; break; } ParsingException parsingException = spec.Errors[key]; spec.Errors.Remove(key); throw parsingException; } } // Spec = spec; initLogic(); enableAllControls(); // EnableAllControls(); } } catch (ParsingException ex) { } catch (Exception ex) { } } while (false); return(spec); }
public void SpecificationOrSpecificationFalseTest(string name, int count) { var spec1 = new SpecificationBase <SimpleTestObject>(t => t.Name == name); var spec2 = new SpecificationBase <SimpleTestObject>(t => t.Count == count); var spec = spec1 | spec2; Assert.False(spec.IsSatisfiedBy(SimpleTestObject.Create_For_Test_Where_Count_Is_Five_And_Name_Is_Name())); Assert.False(spec.Or(spec2).IsSatisfiedBy(SimpleTestObject.Create_For_Test_Where_Count_Is_Five_And_Name_Is_Name())); }
public void Configuration_NewOrderSpecification_ShouldBeCorrectlyConfigured() { var configuration = new SpecificationBase <Entity>(new OrderSpecification <Entity, int>(x => x.Value1)); configuration.QuerySpecification.Internal.Should().NotBeNull(); configuration.QuerySpecification.Should().NotBeNull(); configuration.QuerySpecification.AsExpression().Should().BeNull(); configuration.QuerySpecification.AsFunc().Should().BeNull(); configuration.OrderSpecifications.Count.Should().Be(1); }
/// <summary> /// Assertion Initialization to create the initial step based on the concrete types. /// This method shall be invoked after the parsing immediately to instanciate the initial step /// </summary> /// <param name="spec">The concrete specification of the module</param> public override void Initialize(SpecificationBase spec) { //initialize model checking options, the default option is for deadlock/reachablity algorithms ModelCheckingOptions = new ModelCheckingOptions(); List <string> DeadlockEngine = new List <string>(); DeadlockEngine.Add(Constants.ENGINE_SMT_DTMC); DeadlockEngine.Add(Constants.ENGINE_SMT_MDP); ModelCheckingOptions.AddAddimissibleBehavior(Constants.COMPLETE_BEHAVIOR, DeadlockEngine); }
public void Configuration_NewSpecification_ShouldBeCorrectlyConfigured() { var configuration = new SpecificationBase <Entity>(new Specification <Entity>()); configuration.QuerySpecification.Internal.Should().NotBeNull(); configuration.QuerySpecification.Should().NotBeNull(); configuration.QuerySpecification.AsExpression().Should().BeNull(); configuration.QuerySpecification.AsFunc().Should().BeNull(); configuration.OrderSpecifications.Any().Should().BeFalse(); }
public IQueryable<Loan> FindElementsBy(SpecificationBase<Loan> spec) { Loan[] loans = new[]{ new Loan(){DateTaken = DateTime.Now.AddDays(-15) , LoanPeriod = new TimeSpan(14,0,0,0),Amount = 15000.0}, new Loan(){DateTaken = DateTime.Now.AddDays(-5), LoanPeriod = new TimeSpan(6,0,0,0),Amount = 10000.0}, new Loan(){DateTaken = DateTime.Now.AddDays(-7), LoanPeriod = new TimeSpan(6,0,0,0),Amount = 5000.0} }; return spec.SatisfyingElementsFrom(loans.AsQueryable()); }
//Exception Logging for the application public static void LogException(Exception ex, SpecificationBase spec) { ExceptionDialog log = new ExceptionDialog(ex, APPLICATION_NAME, spec); log.ShowDialog(); if (Common.Utility.Utilities.IsWindowsOS) { FlashWindowEx(log); } }
// handle translation : TODO manage paging, orderby & translation public async Task <IEnumerable <T> > FindAsync(SpecificationBase <T> specification, CancellationToken cancellationToken = default) { return(EnableTranslation && _lexiconDictionary.IsMultiLingualEntity(typeof(T)) ? _lexiconDictionary.Translate( await ApplySpecification(specification) .ToListAsync(cancellationToken), _userContext?.Identity.LanguageIsoCode) : await ApplySpecification(specification) .ToListAsync(cancellationToken)); }
public static void Initialize(AssertionBase Assertion, PetriNet Process, SpecificationBase spec) { Specification Spec = spec as Specification; //get the relevant global variables; remove irrelevant variables so as to save memory; Valuation GlobalEnv = Spec.SpecValuation.GetClone(); //Initialize InitialStep Assertion.InitialStep = new PNConfiguration(Process, Constants.INITIAL_EVENT, null, GlobalEnv, false, spec); }
// This method is called on a worker thread (via asynchronous // delegate invocation). This is where we call the operation (as // defined in the deriving class's DoWork method). public void InternalStart() { // isRunning is set during Start to avoid a race condition try { Spec = CurrentModule.ParseSpecification(this.Text, Options, File); OnReturnResult(); } catch (CancelRunningException) { AcknowledgeCancel(); } catch (Exception e) { // Raise the Failed event. We're in a catch handler, so we // had better try not to throw another exception. try { if (e is System.OutOfMemoryException) { e = new PAT.Common.Classes.Expressions.ExpressionClass.OutOfMemoryException(""); } FailOperation(e); } catch { } // The documentation recommends not catching // SystemExceptions, so having notified the caller we // rethrow if it was one of them. if (e is SystemException) { throw; } } lock (this) { // If the operation wasn't cancelled (or if the UI thread // tried to cancel it, but the method ran to completion // anyway before noticing the cancellation) and it // didn't fail with an exception, then we complete the // operation - if the UI thread was blocked waiting for // cancellation to complete it will be unblocked, and // the Completion event will be raised. if (!cancelAcknowledgedFlag && !failedFlag) { CompleteOperation(); } } }
public static void LockSharedData(SpecificationBase specification) { if (ShareDataLock != null && ShareDataLock.ToString() == "True") { lock (ShareDataLock) { ShareDataLock = specification; specification.LockSpecificationData(); } } }
public SpecificationWorker(PNExtendInfo pnExtendInfo, SpecificationBase spec, ISpecificationWorker listener, Form parentFrm) { mExtendInfo = pnExtendInfo; mSpec = spec; mListener = listener; mForm = parentFrm; // Setup timer mTimer = new Timer(); mTimer.Tick += MCTimer_Tick; mTimer.Interval = 1000; }
/// <summary> /// Assertion Initialization to create the initial step based on the concrete types. /// This method shall be invoked after the parsing immediately to instanciate the initial step /// </summary> /// <param name="spec">The concrete specification of the module</param> public override void Initialize(SpecificationBase spec) { //initialize model checking options, the default option is for deadlock/reachablity algorithms ModelCheckingOptions = new ModelCheckingOptions(); List <string> engines = new List <string>(); engines.Add(Constants.ENGINE_FD_REFINEMENT_ANTICHAIN_DEPTH_FIRST_SEARCH); engines.Add(Constants.ENGINE_FD_REFINEMENT_ANTICHAIN_BREADTH_FIRST_SEARCH); engines.Add(Constants.ENGINE_FD_REFINEMENT_DEPTH_FIRST_SEARCH); engines.Add(Constants.ENGINE_FD_REFINEMENT_BREADTH_FIRST_SEARCH); ModelCheckingOptions.AddAddimissibleBehavior(Constants.COMPLETE_BEHAVIOR, engines); }
public void NotSpecificationTest(string name) { var trueSpec = new SpecificationBase <SimpleTestObject>(t => t.Name == name); var falseSpec = !trueSpec; Assert.True(trueSpec.IsSatisfiedBy(SimpleTestObject.Create_For_Test_Where_Count_Is_Five_And_Name_Is_Name())); Assert.False(falseSpec.IsSatisfiedBy(SimpleTestObject.Create_For_Test_Where_Count_Is_Five_And_Name_Is_Name())); Assert.True(trueSpec.IsSatisfiedBy(SimpleTestObject.Create_For_Test_Where_Count_Is_Five_And_Name_Is_Name())); Assert.False(trueSpec.Not().IsSatisfiedBy(SimpleTestObject.Create_For_Test_Where_Count_Is_Five_And_Name_Is_Name())); }
public virtual SpecificationBase ParseSpecification(string text, string options, string filePath) { if (Common.Classes.Ultility.Ultility.GrabSharedDataLock()) { Specification = InstanciateSpecification(text, options, filePath); return(Specification); } else { MessageBox.Show(Resources.Please_stop_verification_or_simulation_before_parsing_the_model_, Common.Ultility.Ultility.APPLICATION_NAME, MessageBoxButtons.OK, MessageBoxIcon.Exclamation); return(null); } }
public static bool UnLockSharedData(SpecificationBase specification) { //try to lock the data and operations. if (ShareDataLock != null && ShareDataLock == specification) { lock (ShareDataLock) { specification.UnLockSpecificationData(); ShareDataLock = null; } return(true); } return(false); }
public SpecificationBase <T> Create <T>(FilterDescriptor filter) { var expression = this.CreateExpression <T>(filter); if (expression == null) { return(null); } var spec = new SpecificationBase <T>(expression); return(spec); }
public ModelCheckingForm(string Name, SpecificationBase spec) { ModelCheckingFormInstance = this; InitializeComponent(); InitializeResourceText(); this.Spec = spec; int Index = 1; foreach (KeyValuePair <string, AssertionBase> entry in Spec.AssertionDatabase) { ListViewItem item = new ListViewItem(new string[] { "", Index.ToString(), entry.Key }); //if the assertion is LTL, the button of the view BA should be enabled. if (entry.Value is AssertionLTL) { item.Tag = "LTL"; //BuchiAutomata BA = (entry.Value as AssertionLTL).BA; //if (BA != null) //{ // if (BA.HasXOperator) // { // item.SubItems[0].Tag = true; // } //} } //set the question mark image item.ImageIndex = 2; this.ListView_Assertions.Items.Add(item); Index++; } if (Name != "") { #if DEBUG this.Text = this.Text + " (Debug Model) - " + Name; #else this.Text = this.Text + " - " + Name; #endif } this.StatusLabel_Text.Text = Resources.Select_an_assertion_to_start_with; }
public CategoryBuilder(SpecificationBase specification) { this.specification = specification; }