public TestBed(string protocolFilePath, [NotNull] IReportScriptOut reportScriptOut)
        {
            Out = reportScriptOut ?? throw new ArgumentNullException(nameof(reportScriptOut));

            protocolFilePath = CheckFileExistsInCurrentFolderOrScriptsFolder(protocolFilePath);

            var protocol = (IAssayPackageProtocol)AssayPackageManager.AssayPackageManager.UnPack(protocolFilePath);

            if (string.IsNullOrEmpty(protocol.AssayRunDetailsFilePath) || !File.Exists(protocol.AssayRunDetailsFilePath))
            {
                throw new Exception($"The protocol {Path.GetFullPath(protocolFilePath)} is not ready for analysis. Open it in MyAssays Analysis and save, then try again.");
            }

            var pluginsInputStorage = new PluginsInputStorage();

            pluginsInputStorage.StoreAssayXml(protocol.AssayXml.OuterXml);
            pluginsInputStorage.LoadRunDetails(protocol.AssayRunDetailsFilePath);
            pluginsInputStorage.InitialiseTransformInputs();

            var analysisLoggerMock = new Mock <IAnalysisLogger>();

            _data = AnalysisProcessorData.Load(
                pluginsInputStorage.ConfigFilePath,
                pluginsInputStorage.RunDetailsFilePath,
                pluginsInputStorage.PmcFilePath,
                pluginsInputStorage.FieldDataFilePath,
                pluginsInputStorage.AssayFilePath,
                analysisLoggerMock.Object);

            In      = new ReportInMock(_data);
            _script = new Script();
            ((ScriptBase)_script).Init(In, Out);
        }
Ejemplo n.º 2
0
        public bool ExecuteFinal(Core.Script script, Core.Transaction transaction, int transactionInputIndex)
        {
            Contract.Ensures(InFinalState);
            Contract.Ensures(ExecutionResult != null);

            Execute(script, transaction, transactionInputIndex);

            Finish();

            return(this.ExecutionResult == true);
        }
Ejemplo n.º 3
0
        public bool Execute(Core.Script script, Core.Transaction transaction, int transactionInputIndex)
        {
            try
            {
                CurrentScript                = script;
                CurrentTransaction           = transaction;
                CurrentTransactionInputIndex = transactionInputIndex;

                foreach (var atom in script.Atoms)
                {
                    if (this.ExecutionResult.HasValue)
                    {
                        break;
                    }
                    if (!atom.CanExecute(this))
                    {
                        this.HardFailure = true;
                    }
                    atom.Execute(this);

                    if (atom is Atoms.IVerifyAtom && (atom as Atoms.IVerifyAtom).MustVerify)
                    {
                        ExecuteVerify();
                    }

                    if (atom is Atoms.OpAtom)
                    {
                        ++OpAtomsExecuted;
                    }
                    ++CurrentAtomIndex;
                }
            }
            finally
            {
                CurrentScript                = null;
                CurrentTransaction           = null;
                CurrentTransactionInputIndex = 0;
                CurrentAtomIndex             = 0;
                LastSeparatorAtomIndex       = 0;
            }

            return(this.ExecutionResult != false);
        }