public async Task<ExecutionResult> ExecuteAsync(Schema schema, object root, string query, string operationName, Inputs inputs = null)
        {
            var document = _documentBuilder.Build(query);
            var result = new ExecutionResult();

            var validationResult = _documentValidator.IsValid(schema, document, operationName);

            if (validationResult.IsValid)
            {
                var context = BuildExecutionContext(schema, root, document, operationName, inputs);

                if (context.Errors.Any())
                {
                    result.Errors = context.Errors;
                    return result;
                }

                result.Data = await ExecuteOperation(context);
                result.Errors = context.Errors;
            }
            else
            {
                result.Data = null;
                result.Errors = validationResult.Errors;
            }

            return result;
        }
		public ExecutionResult Process(object message, Type messageType)
		{
			var totalResult = new ExecutionResult();
			IMessageConfiguration messageConfiguration = _configuration.GetMessageConfiguration(messageType);

			IEnumerable<ICommandConfiguration> commandConfigurations = messageConfiguration.GetApplicableCommands(message);

			foreach (ICommandConfiguration commandConfiguration in commandConfigurations)
			{
				object commandMessage =
					_mappingEngine.MapUiMessageToCommandMessage(message, messageType, commandConfiguration.CommandMessageType);

				commandConfiguration.Initialize(commandMessage, totalResult);

				ExecutionResult results = _commandInvoker.Process(commandMessage, commandConfiguration);
				totalResult.MergeWith(results);

				if (!totalResult.Successful)
				{
					_unitOfWork.Invalidate();
					break;
				}
			}

			return totalResult;
		}
 private InvocationResult(ExecutionResult result, TimeSpan? rescheduleIn, JobContinuation continuation, Exception exception)
 {
     Result = result;
     RescheduleIn = rescheduleIn;
     Continuation = continuation;
     Exception = exception;
     ConsistencyCheck();
 }
        public static ExecutionResult CompileAndRun(string code)
        {
            var result = new ExecutionResult();
            var CompilerParams = new CompilerParameters
            {
                GenerateInMemory = true,
                TreatWarningsAsErrors = false,
                GenerateExecutable = false,
                CompilerOptions = "/optimize"
            };

            string[] references = {"System.dll", "mscorlib.dll", "System.Core.dll"};
            string[] externalReferences =
            {
                @"Autohaus.Data.dll", @"Sitecore.Kernel.dll", @"Sitecore.Buckets.dll",
                @"Sitecore.ContentSearch.dll", @"Sitecore.ContentSearch.Linq.dll"
            };
            for (int i = 0; i < externalReferences.Length; i++)
                externalReferences[i] =
                    Path.Combine(Path.GetDirectoryName(HttpContext.Current.Request.PhysicalApplicationPath + "bin\\"),
                        externalReferences[i]);

            CompilerParams.ReferencedAssemblies.AddRange(externalReferences);
            CompilerParams.ReferencedAssemblies.AddRange(references);

            var provider = new CSharpCodeProvider();
            CompilerResults compile = provider.CompileAssemblyFromSource(CompilerParams, new[] {code});

            if (compile.Errors.HasErrors)
            {
                result.Messages.AddRange(compile.Errors);
                return result;
            }

            Module module = compile.CompiledAssembly.GetModules()[0];
            Type mt = null;
            MethodInfo methInfo = null;
            if (module != null)
            {
                mt = module.GetType("Autohaus.Web.Runner");
            }

            if (mt != null)
            {
                methInfo = mt.GetMethod("Run");
            }

            if (methInfo == null)
                return result;

            var stopwatch = new Stopwatch();
            stopwatch.Start();
            result.ResultSet = methInfo.Invoke(null, new object[0]) as IEnumerable<object>;
            stopwatch.Stop();
            result.TimeTaken = stopwatch.ElapsedMilliseconds;

            return result;
        }
示例#5
0
 static List<ErrorMessage> Messages(ExecutionResult result)
 {
     return result.Messages.Select(msg => new ErrorMessage
                                          {
                                             InvalidProperty = msg.IncorrectAttribute,
                                             Message = msg.MessageText
                                          })
     .ToList();
 }
示例#6
0
        public void ResultTest()
        {
            var target = new ExecutionResult<String>();
            var expected = RandomValueEx.GetRandomString();
            target.Result = expected;

            target.Result.Should()
                  .Be( expected );
        }
示例#7
0
        public void ExceptionTest()
        {
            var target = new ExecutionResult<String>();
            var expected = new NotImplementedException();
            target.Exception = expected;

            target.Exception.Should()
                  .BeSameAs( expected );
        }
示例#8
0
        public void CtorTest()
        {
            var target = new ExecutionResult<String>();

            target.Exception.Should()
                  .BeNull();
            target.Result.Should()
                  .BeNull();
        }
 /// <summary>
 /// ctor
 /// </summary>
 /// <param name="order">Order for monitoring of execution</param>
 public OrderMonitor(O2GOrderRow order)
 {
     mOrder = order;
     mTrades = new List<O2GTradeRow>();
     mClosedTrades = new List<O2GClosedTradeRow>();
     mState = OrderState.OrderExecuting;
     mResult = ExecutionResult.Executing;
     mTotalAmount = 0;
     mRejectAmount = 0;
     mRejectMessage = "";
 }
示例#10
0
        async Task<ExecutionResult> StartAsyncTask(bool debugMessages)
        {
            execresult = ExecutionResult.ERR_NO_ERRORS;

            var fileExt = fileIO.GetFileNames().Where(i => i.Contains(".")).Select(i => i.Substring(i.LastIndexOf(".")))
                .First(i => KnownExtensions.Contains(i.ToLower()));

            var fnames = fileIO.GetFileNames();

            var story_name = fnames.First(i => i.ToLower().EndsWith(fileExt.ToLower()));

            if (story_name.Length == 0)
            {
                return await Task.FromResult(ExecutionResult.ERR_BADFILE);
            }

            var mem = new List<byte>();
            var fd = fileIO.FOpen(story_name, "rb");
            using (var strm = (await fileIO.GetStreamReaderAsync(fd)).AsStream())
            {
                while (true)
                {
                    var buffer = new byte[4096];
                    var countRead = strm.Read(buffer, 0, 4096);
                    mem.AddRange(buffer);
                    if (countRead <= 0)
                        break;
                }
            }
            
            
            var fe = new Zmachine.FrontEnd(runtime);

            fe.LoadStory(new Zmachine.ImmutableArray<byte>(mem.ToArray()));

            //execresult = await game_begin();
            //if (execresult != ExecutionResult.ERR_NO_ERRORS)
            //    return execresult;

            fe.Zmachine.Restart();
            //execresult = await game_restart();
            //if (execresult != ExecutionResult.ERR_NO_ERRORS)
            //    return execresult;

            for (;;)
            {
                await fe.Zmachine.Run();
                if (!fe.Done)
                    break;
            }

            return await Task.FromResult(execresult);
        }
 public void ParseResult(IList<string> lines)
 {
     if (lines.Count > 0)
     {
         CurrentBranch = lines[0].Replace("On branch ", "");
         ExecutionResult = ExecutionResult.Success;
     }
     else
     {
         ExecutionResult = ExecutionResult.NoRepository;
     }
 }
示例#12
0
        public static void MergeWith(this ModelStateDictionary modelStateDictionary, ExecutionResult executionResult)
        {
            if (executionResult == null) return;

            executionResult
                .Errors
                .Select(error => error.Value)
                .Each(msgGroup => msgGroup
                                      .Messages
                                      .Each(msg => modelStateDictionary.AddModelError(msgGroup.PropertyName, msg)));

        }
示例#13
0
        /// <summary>
        /// Merge all error found in an application message into the current validation dictionary
        /// </summary>
        /// <param name="validationDictionary">instance of IValidationDictionary</param>
        /// <param name="executionResult">instance of IApplicationMessage</param>
        /// <param name="fromMessageCategory">look for error messages from this category</param>
        /// <returns></returns>
        public static IValidationDictionary Merge(this IValidationDictionary validationDictionary, ExecutionResult executionResult, MessageCategory fromMessageCategory = MessageCategory.BrokenBusinessRule)
        {

            if ((validationDictionary != null) && (executionResult != null) && !executionResult.IsSuccessFull)
            {
                var propertyName = executionResult[fromMessageCategory].PropertyName;
                executionResult[fromMessageCategory]
                    .Messages
                    .Each(errorMessage => validationDictionary.AddError(propertyName, errorMessage));
            }

            return validationDictionary;
        }
 /// <summary>
 /// ctor
 /// </summary>
 /// <param name="order">Order for monitoring of execution</param>
 /// <param name="iNetPositionAmount">Initial amount of trade</param>
 public OrderMonitorNetting(O2GOrderRow order, int iNetPositionAmount)
 {
     mOrder = order;
     mTrades = new List<O2GTradeRow>();
     mUpdatedTrades = new List<O2GTradeRow>();
     mClosedTrades = new List<O2GClosedTradeRow>();
     mState = OrderState.OrderExecuting;
     mResult = ExecutionResult.Executing;
     mInitialAmount = iNetPositionAmount;
     mTotalAmount = 0;
     mRejectAmount = 0;
     mRejectMessage = "";
 }
示例#15
0
        public async Task<ExecutionResult> ExecuteAsync(
            ISchema schema,
            object root,
            string query,
            string operationName,
            Inputs inputs = null,
            CancellationToken cancellationToken = default(CancellationToken),
            IEnumerable<IValidationRule> rules = null)
        {
            var result = new ExecutionResult();
            try
            {
                var document = _documentBuilder.Build(query);
                var validationResult = _documentValidator.Validate(query, schema, document, rules);

                if (validationResult.IsValid)
                {
                    var context = BuildExecutionContext(schema, root, document, operationName, inputs, cancellationToken);

                    if (context.Errors.Any())
                    {
                        result.Errors = context.Errors;
                        return result;
                    }

                    result.Data = await ExecuteOperationAsync(context).ConfigureAwait(false);
                    if (context.Errors.Any())
                    {
                        result.Errors = context.Errors;
                    }
                }
                else
                {
                    result.Data = null;
                    result.Errors = validationResult.Errors;
                }

                return result;
            }
            catch (Exception exc)
            {
                if (result.Errors == null)
                {
                    result.Errors = new ExecutionErrors();
                }

                result.Data = null;
                result.Errors.Add(new ExecutionError(exc.Message, exc));
                return result;
            }
        }
示例#16
0
 public static string GetVersion()
 {
     Process p = new Process();
     p.StartInfo.UseShellExecute = false;
     p.StartInfo.RedirectStandardError = true;
     p.StartInfo.RedirectStandardOutput = true;
     p.StartInfo.FileName = "diff3";
     p.StartInfo.Arguments = "--version";
     p.StartInfo.CreateNoWindow = true;
     p.Start();
     p.WaitForExit();
     ExecutionResult result = new ExecutionResult(p);
     Debug.WriteLine(result.StandardOutput);
     return result.StandardOutput;
 }
示例#17
0
 public static string GetRawMerge(string oursPath, string commonPath, string theirPath)
 {
     Process p = new Process();
     p.StartInfo.UseShellExecute = false;
     p.StartInfo.RedirectStandardError = true;
     p.StartInfo.RedirectStandardOutput = true;
     p.StartInfo.FileName = "diff3/bin/diff3.exe";
     p.StartInfo.Arguments = "-m " + oursPath + " "+commonPath+" "+theirPath;
     p.StartInfo.CreateNoWindow = true;
     p.Start();
     p.WaitForExit();
     ExecutionResult result = new ExecutionResult(p);
     if (result.ExitCode == 2)//0 and 1 are ok
     {
         throw new ApplicationException("Got error "+result.ExitCode + " " +result.StandardOutput +" "+ result.StandardError);
     }
     Debug.WriteLine(result.StandardOutput);
     return result.StandardOutput;
 }
        public static void MergeWith(this ModelStateDictionary modelStateDictionary, ExecutionResult executionResult)
        {
            if (executionResult == null) return;

            var messageGroups =
                executionResult
                    .Errors
                    .Select(e => e.Value);

            foreach (var messageGroup in messageGroups)
            {
                foreach (var propertyName in  messageGroup.PropertyNames)
                {
                    foreach (var errorMessage in messageGroup.Messages)
                    {
                        modelStateDictionary.AddModelError(propertyName,errorMessage);
                    }
                }
            }
        }
        public ExecutionResult AssertQuery(
            ISchema schema,
            string query,
            ExecutionResult expectedExecutionResult,
            Inputs inputs,
            object root,
            object userContext = null,
            CancellationToken cancellationToken = default(CancellationToken),
            IEnumerable<IValidationRule> rules = null)
        {
            var runResult = Executer.ExecuteAsync(
                schema,
                root,
                query,
                null,
                inputs,
                userContext,
                cancellationToken,
                rules
                ).Result;

            var writtenResult = Writer.Write(runResult);
            var expectedResult = Writer.Write(expectedExecutionResult);

            #if DEBUG
            Console.WriteLine(writtenResult);
            #endif

            string additionalInfo = null;

            if (runResult.Errors?.Any() == true)
            {
                additionalInfo = string.Join(Environment.NewLine, runResult.Errors
                    .Where(x => x.InnerException is GraphQLSyntaxErrorException)
                    .Select(x => x.InnerException.Message));
            }

            writtenResult.ShouldBe(expectedResult, additionalInfo);

            return runResult;
        }
 public override NodeTreeOutput Tick(out ExecutionResult executionResult, ExecutionResult childResult)
 {
     ((UnityEngine.Transform)refObject.GetValue()).parent = setter.GetValue();
     executionResult = ExecutionResult.Success;
     return(null);
 }
 public override ExecutionResult Run(IStepExecutionContext context)
 {
     Value2 = Value1 + 1;
     return(ExecutionResult.Next());
 }
示例#22
0
        public async Task <ActionResult> _PaymentDetail(Payment model, IEnumerable <HttpPostedFileBase> files)
        {
            if (model.Is_Settlement)
            {
                if (ModelState.ContainsKey("Payee_Type"))
                {
                    ModelState["Payee_Type"].Errors.Clear();
                }

                if (ModelState.ContainsKey("Payee_Contact_Name"))
                {
                    ModelState["Payee_Contact_Name"].Errors.Clear();
                }

                if (ModelState.ContainsKey("Date_Invoice_Received"))
                {
                    ModelState["Date_Invoice_Received"].Errors.Clear();
                }

                if (ModelState.ContainsKey("Payee_Account_Name"))
                {
                    ModelState["Payee_Account_Name"].Errors.Clear();
                }
            }
            else
            {
                if (ModelState.ContainsKey("Payment_Amount"))
                {
                    ModelState["Payment_Amount"].Errors.Clear();
                }

                if (ModelState.ContainsKey("Payment_Date"))
                {
                    ModelState["Payment_Date"].Errors.Clear();
                }
            }

            if (ModelState.IsValid)
            {
                documentService = new DocumentService();
                exeResult       = new ExecutionResult();

                if (Session[SessionHelper.PaymentAttachment] != null)
                {
                    files = (IEnumerable <HttpPostedFileBase>)Session[SessionHelper.PaymentAttachment];
                }

                ClaimTeamLoginModel client = (ClaimTeamLoginModel)Session[SessionHelper.claimTeamLogin];

                if (model.Is_Settlement && model.Payment_Amount.HasValue)
                {
                    model.Total_Gross = (decimal)model.Payment_Amount;
                    model.Total_Net   = (decimal)model.Payment_Amount;
                }

                //  if (model.IsNew)
                //  {
                exeResult = await documentService.CreatePaymentDetailRecord(model, client.UserId, files);

                //}
                //else
                //documentService.CreateFileNoteRecord(model.CreatedBy_Id_Fn, model.ShortDescription_Fn, model.Detail_Fn, model.ClaimId_Fn, model.FileNoteDate_Fn.Value);
                Session[SessionHelper.PaymentAttachment] = null;
            }
            return(Json("success", JsonRequestBehavior.AllowGet));
        }
示例#23
0
        public async Task Transfer(string?memo, bool error)
        {
            NineChroniclesNodeService service = StandaloneContextFx.NineChroniclesNodeService !;
            Currency goldCurrency             = new GoldCurrencyState(
                (Dictionary)BlockChain.GetState(GoldCurrencyState.Address)
                ).Currency;

            Address senderAddress = service.MinerPrivateKey !.ToAddress();
            var     store         = service.Store;
            await BlockChain.MineBlock(service.MinerPrivateKey);

            await BlockChain.MineBlock(service.MinerPrivateKey);

            // 10 + 10 (mining rewards)
            Assert.Equal(
                20 * goldCurrency,
                BlockChain.GetBalance(senderAddress, goldCurrency)
                );

            var     recipientKey = new PrivateKey();
            Address recipient    = recipientKey.ToAddress();
            long    txNonce      = BlockChain.GetNextTxNonce(senderAddress);

            var args = $"recipient: \"{recipient}\", txNonce: {txNonce}, amount: \"17.5\"";

            if (!(memo is null))
            {
                args += $"memo: \"{memo}\"";
            }

            var             query  = $"mutation {{ transfer({args}) }}";
            ExecutionResult result = await ExecuteQueryAsync(query);

            if (error)
            {
                Assert.NotNull(result.Errors);
            }
            else
            {
                Assert.Null(result.Errors);

                var stagedTxIds = BlockChain.GetStagedTransactionIds().ToImmutableList();
                Assert.Single(stagedTxIds);
                string transferTxIdString = stagedTxIds.Single().ToString();
                TxId   transferTxId       = new TxId(ByteUtil.ParseHex(transferTxIdString));

                Transaction <NCAction>?tx = BlockChain.StagePolicy.Get(BlockChain, transferTxId, false);
                Assert.NotNull(tx);
                Assert.IsType <TransferAsset>(tx !.Actions.Single().InnerAction);
                TransferAsset transferAsset = (TransferAsset)tx.Actions.Single().InnerAction;
                Assert.Equal(memo, transferAsset.Memo);

                var expectedResult = new Dictionary <string, object>
                {
                    ["transfer"] = transferTxIdString,
                };

                Assert.Equal(expectedResult, result.Data);

                await BlockChain.MineBlock(recipientKey);

                // 10 + 10 - 17.5(transfer)
                Assert.Equal(
                    FungibleAssetValue.Parse(goldCurrency, "2.5"),
                    BlockChain.GetBalance(senderAddress, goldCurrency)
                    );

                // 0 + 17.5(transfer) + 10(mining reward)
                Assert.Equal(
                    FungibleAssetValue.Parse(goldCurrency, "27.5"),
                    BlockChain.GetBalance(recipient, goldCurrency)
                    );
            }
        }
示例#24
0
 public override ExecutionResult Run(IStepExecutionContext context)
 {
     Console.WriteLine("Hello world");
     return(ExecutionResult.Next());
 }
        async Task<ExecutionResult> execute_instruction()
        {
            execresult = ExecutionResult.ERR_NO_ERRORS;

            byte currentInstruction = memory[program_counter++];
            ushort at;
            short m;
            short n;
            uint u = program_counter - 1;

            var nbuf = new byte[5];
            int argc;
            instruction_use[currentInstruction] |= 0x01;
            if ((currentInstruction & 0x80) != 0)
	        {
                if (currentInstruction >= 0xC0 || currentInstruction == 0xBE)
		        {
                    // variable
                    if (currentInstruction == 0xBE)
		            {
                        currentInstruction = memory[program_counter++];
                    }
                    at = (ushort)(memory[program_counter++] << 8);
                    if (currentInstruction == 0xEC || currentInstruction == 0xFA)
		            {
                        at |= memory[program_counter++];
                    }
		            else
		            {
                        at |= 0x00FF;
                    }
                    if ((at & 0xC000) == 0xC000)
                    {
                        argc = 0;
                    }
                    else if ((at & 0x3000) == 0x3000)
                    {
                        argc = 1;
                    }
                    else if ((at & 0x0C00) == 0x0C00)
                    {
                        argc = 2;
                    }
                    else if ((at & 0x0300) == 0x0300)
                    {
                        argc = 3;
                    }
                    else if ((at & 0x00C0) == 0x00C0)
                    {
                        argc = 4;
                    }
                    else if ((at & 0x0030) == 0x0030)
                    {
                        argc = 5;
                    }
                    else if ((at & 0x000C) == 0x000C)
                    {
                        argc = 6;
                    }
                    else if ((at & 0x0003) == 0x0003)
                    {
                        argc = 7;
                    }
                    else
                    {
                        argc = 8;
                    }
                }
		        else
		        {
                    // short
                    at = (ushort)((currentInstruction << 10) | 0x3FFF);
                    argc = (currentInstruction < 0xB0) ? 1 : 0;
                    if (argc != 0)
                    {
                        currentInstruction &= 0x8F;
                    }
                }
            }
	        else
	        {
                // long
                at = 0x5FFF;
                if ((currentInstruction & 0x20) != 0)
		        {
                    at ^= 0x3000;
                }
                if ((currentInstruction & 0x40) != 0)
		        {
                    at ^= 0xC000;
                }
                currentInstruction &= 0x1F;
                currentInstruction |= 0xC0;
                argc = 2;
            }
            if (break_on)
            {
                if (continuing == u || continuing == program_counter)
                {
                    continuing = 0;
                }
                else
                {
                    if (instruction_bkpt[currentInstruction] != 0)
                    {
                        program_counter = u;
                        await debugger();
                        return execresult;
                    }
                    for (n = 0; n < 16; n++)
                    {
                        if (address_bkpt[n] == u)
                        {
                            program_counter = u;
                            await debugger();
                            return execresult;
                        }
                    }
                }
            }
            for (n = 0; n < 8; n++)
            {
                switch ((at >> (14 - n * 2)) & 3)
                {
                    case 0: // large
                        inst_args[n] = (ushort)(memory[program_counter++] << 8);
                        inst_args[n] |= memory[program_counter++];
                        break;
                    case 1: // small
                        inst_args[n] = memory[program_counter++];
                        break;
                    case 2: // variable
                        inst_args[n] = fetch(memory[program_counter++]);
                        break;
                    case 3: // omit
                        inst_args[n] = 0;
                        break;
                }
            }
            instruction_use[currentInstruction] |= (byte)(argc != 0 ? 0x04 : 0x02);
            lastdebug = false;
            switch (currentInstruction)
	        {
		        case 0x00: // Save game or auxiliary file
		            if (argc != 0)
                    {
                        storei(aux_save());
                    }
                    else
                    {
                        await game_save(memory[program_counter++]);
                    }
                    break;
		        case 0x01: // Restore game or auxiliary file
		            storei(argc != 0 && auxfile != null ? aux_restore() : 0);
                    if (argc == 0)
                    {
                        await game_restore();
                    }
                    break;
		        case 0x02: // Logical shift
		            if ((short) inst_args[1] > 0)
                    {
                        storei(inst_args[0] << inst_args[1]);
                    }
                    else
                    {
                        storei(inst_args[0] >> -inst_args[1]);
                    }
                    break;
		        case 0x03: // Arithmetic shift
		            if ((short) inst_args[1] > 0)
                    {
                        storei((short) inst_args[0] << (short) inst_args[1]);
                    }
                    else
                    {
                        storei((short) inst_args[0] >> -(short) inst_args[1]);
                    }
                    break;
        		case 0x04: // Set font
		            await text_flush();
                    if (execresult != ExecutionResult.ERR_NO_ERRORS)
                        return execresult;
                    storei((inst_args[inst_args_index] == 1 || inst_args[inst_args_index] == 4) ? 4 : 0);
                    //if (opts['t'] == 0)
                    //{
                    //    Console.Write(inst_args == 3 ? 14 : 15);
                    //}
                    break;
    		    case 0x08: // Set margins
		            if (!window )
                    {
                        lmargin = inst_args[0];
                        rmargin = inst_args[1];
                        if (zmachineVersion == 5)
                        {
                            write16(40, inst_args[0]);
                        }
                        if (zmachineVersion == 5)
                        {
                            write16(41, inst_args[1]);
                        }
                        while (cur_column < (int)inst_args[0])
                        {
                             runtime.Write(' ');
                            //Console.Write(32);
                            cur_column++;
                        }
                    }
                    break;
		        case 0x09: // Save undo buffer
		            if (allow_undo)
                    {
                        //C++ TO C# CONVERTER TODO TASK: The memory management function 'memcpy' has no equivalent in C#:
                        //memcpy(u_frames, frames, sizeof(StackFrame));
                        Array.Copy(u_frames, frames, 1);
                        //C++ TO C# CONVERTER TODO TASK: The memory management function 'memcpy' has no equivalent in C#:
                        //memcpy(u_stack, stack, sizeof(ushort));
                        Array.Copy(u_stack, stack, 1);
                        //C++ TO C# CONVERTER TODO TASK: The memory management function 'memcpy' has no equivalent in C#:
                        //memcpy(undomem, memory + 0x40, static_start - 0x40);
                        Array.Copy(undomem, 0, memory, 0x40, (int)static_start - 0x40);
                        u_frameptr = frameptr;
                        u_stackptr = stackptr;
                        u_program_counter = program_counter;
                        storei(1);
                    }
                    else
                    {
                        storei(-1);
                    }
                    break;
		        case 0x0A: // Restore undo buffer
		            if (allow_undo)
                    {
                        //C++ TO C# CONVERTER TODO TASK: The memory management function 'memcpy' has no equivalent in C#:
                        //memcpy(frames, u_frames, sizeof(StackFrame));
                        Array.Copy(frames, u_frames, 1);

                        //C++ TO C# CONVERTER TODO TASK: The memory management function 'memcpy' has no equivalent in C#:
                        //memcpy(stack, u_stack, sizeof(ushort));
                        Array.Copy(stack, u_stack, 1);

                        //C++ TO C# CONVERTER TODO TASK: The memory management function 'memcpy' has no equivalent in C#:
                        //memcpy(memory + 0x40, undomem, static_start - 0x40);
                        Array.Copy(memory, 0x40, undomem, 0, (int) static_start - 0x40);
                        frameptr = u_frameptr;
                        stackptr = u_stackptr;
                        program_counter = u_program_counter;
                        storei((argc != 0 && zmachineVersion > 8) ? inst_args[0] : 2);
                    }
                    else
                    {
                        storei(-1);
                    }
                    break;
		        case 0x0B: // Call byte address
		            program_counter++;
                    enter_routine(inst_args[inst_args_index], true, argc - 1);
                    break;
		        case 0x0C: // Get reference to stack or local variables
		            if (inst_args != null)
                    {
                        storei(stackptr - 1);
                    }
                    else
                    {
                        storei(frames[(int)frameptr].start + inst_args[inst_args_index - 1]);
                    }
                    break;
		        case 0x0D: // Read through stack/locals reference
		            storei(stack[inst_args[inst_args_index]]);
                    break;
		        case 0x0E: // Write through stack/locals reference
		            if (inst_args[inst_args_index] < 1024)
                    {
                        stack[inst_args[inst_args_index]] = inst_args[1];
                    }
                    break;
		        case 0x0F: // Read byte from long property
		            u = property_address(inst_args[0], (byte)inst_args[1]);
                    storei(memory[u]);
                    break;
		        case 0x1D: // Read word from long property
		            u = property_address(inst_args[0], (byte) inst_args[1]);
                    storei(read16((int)u));
                    break;
		        case 0x80: // Jump if zero
		            branch(inst_args[inst_args_index] == 0 );
                    break;
		        case 0x81: // Sibling
		            storei(sibling(inst_args[inst_args_index]));
                    branch(sibling(inst_args[inst_args_index]) != 0);
                break;
		        case 0x82: // Child
                    storei(child(inst_args[inst_args_index]));
                    branch(child(inst_args[inst_args_index]) != 0);
                    break;
		        case 0x83: // Parent
                    storei(parent(inst_args[inst_args_index]));
                    break;
		        case 0x84: // Property length
                    currentInstruction = memory[inst_args[inst_args_index] - 1];
                    storei(zmachineVersion < 4 ? 
                        (currentInstruction >> 5) + 1:
                        ( (currentInstruction & 0x80) != 0 ? 
                            ( (currentInstruction & 63) == 0 ? 
                                64 :
                                ((currentInstruction >> 6) +1)
                            ) : ((currentInstruction >> 6) + 1)
                        )
                    );
                    break;
		        case 0x85: // Increment
		            store((byte) inst_args[inst_args_index], (byte)(fetch((byte) inst_args[inst_args_index]) + 1));
                    break;
		        case 0x86: // Decrement
		            store((byte) inst_args[inst_args_index], (byte) fetch((byte) inst_args[inst_args_index]) - 1);
                    break;
		        case 0x87: // Print by byte address
		            text_print(inst_args[inst_args_index]);
                    break;
		        case 0x88: // Call routine
		            if (inst_args[inst_args_index] != 0)
                    {
                        program_counter++;
                        enter_routine((uint)((inst_args[inst_args_index] << packed_shift) + routine_start), true, argc - 1);
                    }
                    else
                    {
                        storei(0);
                    }
                    break;
		        case 0x89: // Remove object
		            insert_object(inst_args[inst_args_index], 0);
                    break;
		        case 0x8A: // Print short name of object
                           //text_print(obj_prop_addr((uint)(inst_args[inst_args_index] + 1)));
                    text_print(Frotz.Generic.ZObject.object_name((ushort)(inst_args[inst_args_index] + 1)));
                    break;
		        case 0x8B: // Return
		            exit_routine(inst_args[inst_args_index]);
                    break;
		        case 0x8C: // Unconditional jump
		            program_counter += (uint)((short) inst_args[inst_args_index] - 2);
                    break;
		        case 0x8D: // Print by packed address
		            text_print((uint)((inst_args[inst_args_index] << packed_shift) + text_start));
                    break;
		        case 0x8E: // Load variable
		            at = fetch((byte) inst_args[inst_args_index]);
                    store((byte) inst_args[inst_args_index], at); // if it popped from the stack, please put it back on
                    storei(at);
                    break;
		        case 0x8F: // Not // Call routine and discard result
		            if (zmachineVersion > 4)
                    {
                        if (inst_args[inst_args_index] != 0)
                        {
                            enter_routine((uint) ((inst_args[inst_args_index] << packed_shift) + routine_start), false, argc - 1);
                        }
                    }
                    else
                    {
                        storei(~inst_args[inst_args_index]);
                    }
                    break;
		        case 0xB0: // Return 1
		            exit_routine(1);
                    break;
		        case 0xB1: // Return 0
		            exit_routine(0);
                    break;
		        case 0xB2: // Print literal
		            program_counter = text_print(program_counter);
                    break;
		        case 0xB3: // Print literal and return
		            program_counter = text_print(program_counter);
                    char_print(13);
                    exit_routine(1);
                    break;
		        case 0xB4: // No operation
		            //NOP
		            break;
		        case 0xB5: // Save
		            if (zmachineVersion > 3)
                    {
                        await game_save(memory[program_counter++]);
                    }
                    else
                    {
                        await game_save(0);
                    }
                    break;
		        case 0xB6: // Restore
		            if (zmachineVersion > 3)
                    {
                        storei(0);
                    }
                    else
                    {
                        branch(false);
                    }
                    await game_restore();
                    break;
        		case 0xB7: // Restart
		            game_restart();
                    break;
		        case 0xB8: // Return from stack
		            exit_routine((ushort) stack[stackptr - 1]);
                    break;
		        case 0xB9: // Discard from stack // Catch
		            if (zmachineVersion > 4)
                    {
                        storei(frameptr);
                    }
                    else
                    {
                        stackptr--;
                    }
                    break;
		        case 0xBA: // Quit
		            await text_flush();
                    return await Task.FromResult(ExecutionResult.ERR_STATE_QUIT);
                    break;
		        case 0xBB: // Line break
		            char_print(13);
                    break;
		        case 0xBC: // Show status
		            //NOP
		            break;
		        case 0xBD: // Verify checksum
		            branch(verify_checksum());
                    break;
		        case 0xBF: // Check if game disc is original
		            branch(original);
                    break;
		        case 0xC1: // Branch if equal
		            for (n = 1; n < argc; n++)
                    {
                        if (inst_args[inst_args_index] == inst_args[n])
                        {
                            branch(true);
                            break;
                        }
                    }
                    if (n == argc)
                    {
                        branch(false);
                    }
                    break;
		        case 0xC2: // Jump if less
		            branch((short) inst_args[0] < (short) inst_args[1]);
                    break;
		        case 0xC3: // Jump if greater
		            branch((short) inst_args[0] > (short) inst_args[1]);
                    break;
		        case 0xC4: // Decrement and branch if less
		            store((byte)inst_args[inst_args_index], n = (short)(fetch((byte)inst_args[inst_args_index]) - 1));
                    branch(n < (short) inst_args[1]);
                    break;
		        case 0xC5: // Increment and branch if greater
		            store((byte)inst_args[inst_args_index], n = (short)(fetch((byte) inst_args[inst_args_index]) + 1));
                    branch(n > (short) inst_args[1]);
                    break;
		        case 0xC6: // Check if one object is the parent of the other
		            branch(parent(inst_args[0]) == inst_args[1]);
                    break;
		        case 0xC7: // Test bitmap
		            branch((inst_args[0] & inst_args[1]) == inst_args[1]);
                    break;
		        case 0xC8: // Bitwise OR
		            storei(inst_args[0] | inst_args[1]);
                    break;
		        case 0xC9: // Bitwise AND
		            storei(inst_args[0] & inst_args[1]);
                    break;
		        case 0xCA: // Test attributes
		            branch( (memory[attribute(inst_args[inst_args_index]) + (inst_args[1] >> 3)] & (0x80 >> (inst_args[1] & 7))) != 0);
                    break;
		        case 0xCB: // Set attribute
                    memory[(int)(attribute(inst_args[inst_args_index]) + (inst_args[1] >> 3))] |= (byte)(0x80 >> (inst_args[1] & 7));
                    break;
        		case 0xCC: // Clear attribute
                    memory[(int)(attribute(inst_args[inst_args_index]) + (inst_args[1] >> 3))] &= (byte)(~(0x80 >> (inst_args[1] & 7)));
                    break;
    		    case 0xCD: // Store to variable
		            fetch((byte) inst_args[0]);
                    store((byte) inst_args[0], inst_args[1]);
                    break;
		        case 0xCE: // Insert object
		            insert_object(inst_args[0], inst_args[1]);
                    break;
		        case 0xCF: // Read 16-bit number from RAM/ROM
		            storei(read16(inst_args[0] + ((short) inst_args[1] << 1)));
                    break;
		        case 0xD0: // Read 8-bit number from RAM/ROM
		            storei(memory[inst_args[0] + (short) inst_args[1]]);
                    break;
		        case 0xD1: // Read property
		            if ((u = (uint) property_address(inst_args[0], (byte) inst_args[1])) != 0)
                    {
                        storei(cur_prop_size == 1 ? memory[u] : read16((int)u));
                    }
                    else
                    {
                        storei(read16((int)(object_table + (inst_args[1] << 1) - 2)));
                    }
                    break;
		        case 0xD2: // Get address of property
		            storei((int) property_address(inst_args[0], (byte) inst_args[1]));
                    break;
		        case 0xD3: // Find next property
		            if (inst_args[1] != 0)
                    {
                        u = property_address(inst_args[0], (byte) inst_args[1]);
                        u += cur_prop_size;
                        storei(memory[u] & (zmachineVersion > 8 && ((memory[u] & 128) != 0) ? 127 : zmachineVersion > 3 ? 63 : 31));
                    }
                    else
                    {
                        u = (uint)obj_prop_addr((uint)inst_args[0]);
                        u += (uint) ((memory[(int)u] << 1) + 1);
                        storei(memory[u] & (zmachineVersion > 8 && ((memory[u] & 128) != 0) ? 127 : zmachineVersion > 3 ? 63 : 31));
                    }
                    break;
		        case 0xD4: // Addition
		            storei((short) inst_args[0] + (short) inst_args[1]);
                    break;
		        case 0xD5: // Subtraction
		            storei((short) inst_args[0] - (short) inst_args[1]);
                    break;
		        case 0xD6: // Multiplication
		            storei((short) inst_args[0] * (short) inst_args[1]);
                    break;
		        case 0xD7: // Division
		            if (inst_args[1] != 0)
                    {
                        n = (short)((short) inst_args[0] / (short) inst_args[1]);
                    }
                    else
                    {
                        runtime.Debug.LogError("\n*** Division by zero\n{0}\n", currentInstruction);
                    }
                    storei(n);
                    break;
		        case 0xD8: // Modulo
		            if (inst_args[1] != 0)
                    {
                        n = (short) ((short) inst_args[0] % (short) inst_args[1]);
                    }
                    else
                    {
                        runtime.Debug.LogError("\n*** Division by zero\n{0}\n", currentInstruction);
                    }
                    storei(n);
                    break;
		        case 0xD9: // Call routine
		            if (inst_args[inst_args_index] != 0)
                    {
                        program_counter++;
                        enter_routine((uint)(inst_args[inst_args_index] << packed_shift) + routine_start, true, argc - 1);
                    }
                    else
                    {
                        storei(0);
                    }
                    break;
		        case 0xDA: // Call routine and discard result
		            if (inst_args[inst_args_index] != 0)
                    {
                        enter_routine((uint)(inst_args[inst_args_index] << packed_shift) + routine_start, false, argc - 1);
                    }
                    break;
		        case 0xDB: // Set colors
		            //NOP
		            break;
		        case 0xDC: // Throw
		            frameptr = inst_args[1];
                    exit_routine(inst_args[inst_args_index]);
                    break;
		        case 0xDD: // Bitwise XOR
		            storei(inst_args[0] ^ inst_args[1]);
                    break;
		        case 0xE0: // Call routine // Read from extended RAM
		            if (zmachineVersion > 8)
                    {
                        u = (uint)((inst_args[0] << address_shift) + (inst_args[1] << 1) + inst_args[2]);
                        storei(read16((int)u));
                    }
                    else if (inst_args[inst_args_index] != 0)
                    {
                        program_counter++;
                        enter_routine((uint)(inst_args[inst_args_index] << packed_shift) + routine_start, true, argc - 1);
                    }
                    else
                    {
                        storei(0);
                    }
                    break;
		        case 0xE1: // Write 16-bit number to RAM
		            write16(inst_args[0] + ((short) inst_args[1] << 1), inst_args[2]);
                    break;
		        case 0xE2: // Write 8-bit number to RAM
		            memory[inst_args[0] + (short) inst_args[1]] = (byte) inst_args[2];
                    break;
		        case 0xE3: // Write property
		            u = property_address(inst_args[0], (byte) inst_args[1]);
                    if (cur_prop_size == 1)
                    {
                        memory[u] = (byte) inst_args[2];
                    }
                    else
                    {
                        write16((int)u, inst_args[2]);
                    }
                    break;
		        case 0xE4: // Read line of input
		            n = await line_input();
                    if (execresult != ExecutionResult.ERR_NO_ERRORS)
                        return execresult;

                    if (zmachineVersion > 4 && !lastdebug)
                    {
                        storei(n);
                    }
                    break;
		        case 0xE5: // Print character
		            char_print((byte)inst_args[inst_args_index]);
                    break;
		        case 0xE6: // Print number
		            n = (short) inst_args[inst_args_index];
                    if (n == -32768)
                    {
                        char_print('-');
                        char_print('3');
                        char_print('2');
                        char_print('7');
                        char_print('6');
                        char_print('8');
                    }
                    else
                    {
                        nbuf[0] = nbuf[1] = nbuf[2] = nbuf[3] = nbuf[4] = 0;
                        if (n < 0)
                        {
                            char_print('-');
                            n *= -1;
                        }
                        nbuf[4] = (byte)( (n % 10) | '0');
                        if ((n /= 10) != 0)
                        {
                            nbuf[3] = (byte) ((n % 10) | '0');
                        }
                        if ((n /= 10) != 0)
                        {
                            nbuf[2] = (byte) ((n % 10) | '0');
                        }
                        if ((n /= 10) != 0)
                        {
                            nbuf[1] = (byte) ((n % 10) | '0');
                        }
                        if ((n /= 10) != 0)
                        {
                            nbuf[0] = (byte) ((n % 10) | '0');
                        }
                        char_print(nbuf[0]);
                        char_print(nbuf[1]);
                        char_print(nbuf[2]);
                        char_print(nbuf[3]);
                        char_print(nbuf[4]);
                    }
                    break;
		        case 0xE7: // Random number generator
                    if ((short) inst_args[inst_args_index] > 0)
                    {
                        storei(get_random((short) inst_args[inst_args_index]));
                    }
                    else
                    {
                        randomize((ushort)(-(short) inst_args[inst_args_index]));
                        storei(0);
                    }
                    break;
		        case 0xE8: // Push to stack
		            stack[stackptr++] = inst_args[inst_args_index];
                    break;
		        case 0xE9: // Pop from stack
		            if (inst_args[inst_args_index] != 0)
                    {
                        store((byte) inst_args[inst_args_index], stack[--stackptr]);
                    }
                    else
                    {
                        stack[stackptr - 2] = stack[stackptr - 1];
                        stackptr--;
                    }
                    break;
		        case 0xEA: // Split window
		            //NOP
		            break;
		        case 0xEB: // Set active window
		            window = inst_args[inst_args_index] != 0;
                    break;
		        case 0xEC: // Call routine
		            if (inst_args[inst_args_index] != 0)
                    {
                        program_counter++;
                        enter_routine((uint)(inst_args[inst_args_index] << packed_shift) + routine_start, true, argc - 1);
                    }
                    else
                    {
                        storei(0);
                    }
                    break;
		        case 0xED: // Clear window
		            if (inst_args[inst_args_index] != 1)
                    {
                        runtime.Write('\n');
                        textptr = 0;
                        cur_row = 2;
                        cur_column = 0;
                        while (cur_column < lmargin)
                        {
                            runtime.Write((char)32);
                            cur_column++;
                        }
                    }
                    break;
		        case 0xEE: // Erase line
		            //NOP
		            break;
		        case 0xEF: // Set cursor position
		            //NOP
		            break;
		        case 0xF0: // Get cursor position
		            if (window)
                    {
                        memory[inst_args[inst_args_index]] = (byte)sc_rows;
                        memory[inst_args[inst_args_index + 1]] = (byte) (cur_column + 1);
                    }
                    else
                    {
                        memory[inst_args[inst_args_index]] = 0;
                        memory[inst_args[inst_args_index + 1]] = 0;
                    }
                    break;
		        case 0xF1: // Set text style
		            //NOP
		            break;
		        case 0xF2: // Buffer mode
		            buffering = inst_args[inst_args_index] != 0;
                    break;
		        case 0xF3: // Select output stream
		            switch_output((short) inst_args[inst_args_index]);
                    break;
		        case 0xF4: // Select input stream
		            if (inlog != 0)
                    {
                        from_log = inst_args[inst_args_index] != 0;
                    }
                    break;
		        case 0xF5: // Sound effects
                    //runtime.Write((char)7); //Console.Write(7);
                    break;
		        case 0xF6: // Read a single character
		            n = (short)(await char_input());
                    if (execresult != ExecutionResult.ERR_NO_ERRORS)
                        return execresult;

                    if (lastdebug)
                    {
                        storei(n);
                    }
                    break;
		        case 0xF7: // Scan a table
		            if (argc < 4)
                    {
                        inst_args[3] = 0x82;
                    }
                    u = inst_args[1];
                    while (inst_args[2] != 0)
                    {
                        if (inst_args[0] == ((inst_args[3] & 0x80) != 0 ? read16((int)u) : memory[u]))
                            break;
                        u += (uint)inst_args[3] & 0x7F;
                        inst_args[2]--;
                    }
                    storei((int) (inst_args[2] != 0 ? u : 0));
                    branch(inst_args[2] != 0);
                    break;
		        case 0xF8: // Not
		            storei(~inst_args[inst_args_index]);
                    break;
		        case 0xF9: // Call routine and discard results // Write extended RAM
		            if (zmachineVersion > 8)
                    {
                        u = ((uint)inst_args[0] << address_shift) + ((uint) inst_args[1] << 1) + (uint)inst_args[2];
                        write16((int)u, inst_args[3]);
                    }
                    else if (inst_args[inst_args_index] != 0)
                    {
                        enter_routine((uint) ((inst_args[inst_args_index] << packed_shift) + routine_start), false, argc - 1);
                    }
                    break;
		        case 0xFA: // Call routine and discard results
		            if (inst_args[inst_args_index] != 0)
                    {
                        enter_routine((uint) ((inst_args[inst_args_index] << packed_shift) + routine_start), false, argc - 1);
                    }
                    break;
		        case 0xFB: // Tokenise text
		            if (argc < 4)
                    {
                        inst_args[3] = 0;
                    }
                    if (argc < 3)
                    {
                        inst_args[2] = 0;
                    }
                    tokenise((uint)(inst_args[0] + 2), inst_args[2], inst_args[1], memory[inst_args[0] + 1], inst_args[3]);
                    break;
		        case 0xFC: // Encode text in dictionary format
                    var buffr = new byte[255];
                    Array.Copy(memory, (int) (inst_args[0] + inst_args[2]), buffr, 0, 256);
		            ulong execute_instruction_y = dictionary_encode(buffr, inst_args[1]);
                    
                    write16(inst_args[3], (ushort)(execute_instruction_y >> 16));
                    write16(inst_args[3] + 2, (ushort) (execute_instruction_y >> 8));
                    write16(inst_args[3] + 4, (ushort) execute_instruction_y);
                    break;
		        case 0xFD: // Copy a table
		            if (inst_args[1] == 0)
                    {
                        // zero!
                        while (inst_args[2] != 0)
                        {
                            memory[inst_args[0] + --inst_args[2]] = 0;
                        }
                    }
                    else if ((short) inst_args[2] > 0 && inst_args[1] > inst_args[0])
                    {
                        // backward!
                        m = (short) inst_args[2];
                        while (m-- != 0)
                        {
                            memory[inst_args[1] + m] = memory[inst_args[0] + m];
                        }
                    }
                    else
                    {
                        // forward!
                        if ((short) inst_args[2] < 0)
                        {
                            inst_args[2] = (ushort) (inst_args[2] * -1);
                        }
                        m = 0;
                        while (m < (short) inst_args[2])
                        {
                            memory[inst_args[1] + m] = memory[inst_args[0] + m];
                            m++;
                        }
                    }
                    break;
		        case 0xFE: // Print a rectangle of text
		            make_rectangle(inst_args[0], inst_args[1], argc > 2 ? inst_args[2] : 1, argc > 3 ? (short) inst_args[3] : 0);
                    // (I assume the skip is signed, since many other things are, and +32768 isn't useful anyways.)
                    break;
		        case 0xFF: // Check argument count
		            branch(frames[frameptr].argc >= (byte) inst_args[inst_args_index]);
                    break;
                default:
                    runtime.Debug.LogError("\n*** Invalid instruction: {0:X2} (near {1:X6})\n", currentInstruction, program_counter);
                    return await Task.FromResult(ExecutionResult.ERR_UNKNOWN);
                    break;
            }
            return await Task.FromResult(execresult);
        }
示例#26
0
 public virtual void ExecutionResult(C context, ExecutionResult mystruct)
 {
 }
示例#27
0
        public bool ExportExecutionDetailsToRQM(BusinessFlow businessFlow, ref string result, bool exectutedFromAutomateTab = false, PublishToALMConfig publishToALMConfig = null)
        {
            result = string.Empty;
            string bfExportedID = GetExportedIDString(businessFlow.ExternalID, "RQMID");

            if (string.IsNullOrEmpty(bfExportedID) || bfExportedID.Equals("0"))
            {
                result = GingerDicser.GetTermResValue(eTermResKey.BusinessFlow) + ": " + businessFlow.Name + " is missing ExternalID, cannot export RQM TestPlan execution results without External ID";
                return(false);
            }

            if (businessFlow.ActivitiesGroups.Count == 0)
            {
                result = GingerDicser.GetTermResValue(eTermResKey.BusinessFlow) + ": " + businessFlow.Name + " Must have at least one " + GingerDicser.GetTermResValue(eTermResKey.ActivitiesGroup);
                return(false);
            }

            LoginDTO loginData = new LoginDTO()
            {
                User = ALMCore.DefaultAlmConfig.ALMUserName, Password = ALMCore.DefaultAlmConfig.ALMPassword, Server = ALMCore.DefaultAlmConfig.ALMServerURL
            };

            //
            // get data about execution records per current test plan - start
            RQMTestPlan testPlan             = new RQMTestPlan();
            string      importConfigTemplate = System.IO.Path.Combine(RQMCore.ConfigPackageFolderPath, "RQM_Import", "RQM_ImportConfigs_Template.xml");

            if (File.Exists(importConfigTemplate))
            {
                XmlSerializer serializer = new
                                           XmlSerializer(typeof(RQMProjectListConfiguration));
                FileStream fs     = new FileStream(importConfigTemplate, FileMode.Open);
                XmlReader  reader = XmlReader.Create(fs);
                RQMProjectListConfiguration RQMProjectList;
                RQMProjectList = (RQMProjectListConfiguration)serializer.Deserialize(reader);
                fs.Close();

                RQMProject currentRQMProjectMapping;
                if (RQMProjectList.RQMProjects.Count > 0)
                {
                    currentRQMProjectMapping = RQMProjectList.RQMProjects.Where(x => x.Name == ALMCore.DefaultAlmConfig.ALMProjectName || x.Name == "DefaultProjectName").FirstOrDefault();
                    if (currentRQMProjectMapping != null)
                    {
                        testPlan = RQMConnect.Instance.GetRQMTestPlanByIdByProject(ALMCore.DefaultAlmConfig.ALMServerURL, ALMCore.DefaultAlmConfig.ALMUserName, ALMCore.DefaultAlmConfig.ALMPassword, ALMCore.DefaultAlmConfig.ALMProjectName, GetExportedIDString(businessFlow.ExternalID, "RQMID"));

                        if (testPlan == null)
                        {
                            result = "Recent Testing Plan not exists in connected RQM project.";
                            return(false);
                        }

                        testPlan.RQMExecutionRecords = RQMConnect.Instance.GetExecutionRecordsByTestPlan(loginData, reader, currentRQMProjectMapping, RQMCore.ALMProjectGroupName, RQMCore.ALMProjectGuid, testPlan.URLPathVersioned);
                    }
                }
            }
            // get data about execution records per current test plan - finish

            List <ExecutionResult> exeResultList = new List <ExecutionResult>();

            foreach (ActivitiesGroup activGroup in businessFlow.ActivitiesGroups)
            {
                if ((publishToALMConfig.FilterStatus == FilterByStatus.OnlyPassed && activGroup.RunStatus == eActivitiesGroupRunStatus.Passed) ||
                    (publishToALMConfig.FilterStatus == FilterByStatus.OnlyFailed && activGroup.RunStatus == eActivitiesGroupRunStatus.Failed) ||
                    publishToALMConfig.FilterStatus == FilterByStatus.All)
                {
                    ExecutionResult exeResult = GetExeResultforAg(businessFlow, bfExportedID, activGroup, ref result, testPlan);
                    if (exeResult != null)
                    {
                        exeResultList.Add(exeResult);
                    }
                    else
                    {
                        return(false);
                    }
                }
            }

            ResultInfo resultInfo = new ResultInfo();

            //
            // Updating of Execution Record Results (test plan level)
            try
            {
                resultInfo = RQMConnect.Instance.RQMRep.ExportExecutionResult(loginData, exeResultList, RQMCore.ALMProjectGuid, ALMCore.DefaultAlmConfig.ALMProjectName, RQMCore.ALMProjectGroupName);
            }
            catch
            {
                Reporter.ToLog(eLogLevel.ERROR, "Failed to Update Execution Record Results");
            }

            //
            // Creating Test Suite Log (per test suite)
            try
            {
                foreach (RQMTestSuite rQMTestSuite in testPlan.TestSuites)
                {
                    if ((rQMTestSuite.ACL_TestSuite_Copy != null) && (rQMTestSuite.TestSuiteExecutionRecord.CurrentTestSuiteResult.ACL_TestSuiteLog_Copy != null))
                    {
                        resultInfo = RQMConnect.Instance.RQMRep.CreateTestSuiteLog(loginData, RQMCore.ALMProjectGuid, ALMCore.DefaultAlmConfig.ALMProjectName, RQMCore.ALMProjectGroupName, rQMTestSuite.ACL_TestSuite_Copy, rQMTestSuite.TestSuiteExecutionRecord.CurrentTestSuiteResult.ACL_TestSuiteLog_Copy);
                    }
                }
            }
            catch
            {
                Reporter.ToLog(eLogLevel.ERROR, "Failed to Update Execution Record Results");
            }

            //
            // Attaching of Activity Groups Reports
            try
            {
                // Attach ActivityGroup Report if needed
                if ((publishToALMConfig.ToAttachActivitiesGroupReport) || (exectutedFromAutomateTab))
                {
                    foreach (ActivitiesGroup activGroup in businessFlow.ActivitiesGroups)
                    {
                        try
                        {
                            ACL_Data_Contract.Activity   currentActivity  = GetTestCaseFromActivityGroup(activGroup);
                            ACL_Data_Contract.Attachment reportAttachment = new ACL_Data_Contract.Attachment();
                            string activityGroupName = PathHelper.CleanInValidPathChars(activGroup.Name);
                            if ((activGroup.TempReportFolder != null) && (activGroup.TempReportFolder != string.Empty) &&
                                (System.IO.Directory.Exists(activGroup.TempReportFolder)))
                            {
                                //Creating the Zip file - start
                                string targetZipPath = System.IO.Directory.GetParent(activGroup.TempReportFolder).ToString();
                                string zipFileName   = targetZipPath + "\\" + activityGroupName.ToString().Replace(" ", "_") + "_GingerHTMLReport.zip";
                                if (!System.IO.File.Exists(zipFileName))
                                {
                                    ZipFile.CreateFromDirectory(activGroup.TempReportFolder, zipFileName);
                                }
                                else
                                {
                                    System.IO.File.Delete(zipFileName);
                                    ZipFile.CreateFromDirectory(activGroup.TempReportFolder, zipFileName);
                                }
                                System.IO.Directory.Delete(activGroup.TempReportFolder, true);
                                //Creating the Zip file - finish

                                //Attaching Zip file - start
                                reportAttachment.ClientFileName = activityGroupName.ToString().Replace(" ", "_") + "_GingerHTMLReport.zip";
                                reportAttachment.ServerLocation = targetZipPath + @"\" + reportAttachment.ClientFileName;
                                reportAttachment.CreatedBy      = Environment.UserName;
                                currentActivity.EntityId        = Convert.ToInt32(GetExportedIDString(activGroup.ExternalID.ToString(), "RQMID"));
                                currentActivity.ExportedID      = (long)currentActivity.EntityId;
                                currentActivity.ActivityData.AttachmentsColl = new Attachments();
                                currentActivity.ActivityData.AttachmentsColl.Add(reportAttachment);

                                string exportJarFilePath = Assembly.GetExecutingAssembly().Location.Replace(@"GingerCore.dll", "") + @"ALM\\RQM\\JAVA";
                                RQMConnect.Instance.RQMRep.UploadAttachmetToRQMAndGetIds(loginData, RQMCore.ALMProjectGuid, ALMCore.DefaultAlmConfig.ALMProjectName, RQMCore.ALMProjectGroupName, currentActivity, exportJarFilePath);
                                RQMConnect.Instance.RQMRep.UpdateTestCaseWithNewAttachmentID(loginData, RQMCore.ALMProjectGuid, ALMCore.DefaultAlmConfig.ALMProjectName, RQMCore.ALMProjectGroupName, currentActivity);

                                //Attaching Zip file - finish
                                System.IO.File.Delete(zipFileName);
                            }
                        }
                        catch
                        {
                            Reporter.ToLog(eLogLevel.ERROR, "Failed to attach report Per ActivityGroup - " + activGroup.Name);
                        }
                    }
                }
            }
            catch (Exception e)
            {
                resultInfo.ErrorCode = 1;
                result = e.ToString();
            }

            if (resultInfo.ErrorCode == 0)
            {
                result = "Export execution details to RQM performed successfully.";
                return(true);
            }
            else
            {
                result = resultInfo.ErrorDesc;
            }

            Reporter.ToLog(eLogLevel.ERROR, "Failed to export execution details to RQM/ALM");
            return(false);
        }
示例#28
0
 /// <summary>
 /// Initializes an instance of <see cref="StandardErrorValidationException"/>.
 /// </summary>
 public StandardErrorValidationException(ExecutionResult executionResult)
     : base(executionResult, CreateExceptionMessage(executionResult))
 {
 }
示例#29
0
        public Task <IExecutionResult> PublishAsync(ICommandBus commandBus, CancellationToken cancellationToken)
        {
            var result = ExecutionResult.Failed("not run from here");

            return(Task.FromResult(result));
        }
示例#30
0
        //private readonly IApplicationTaskLogic _applicationWorkflow;

        //public CreateAppStep(IApplicationTaskLogic applicationWorkflow)
        //{
        //    _applicationWorkflow = applicationWorkflow;
        //}

        public override ExecutionResult Run(IStepExecutionContext context)
        {
            //_applicationWorkflow.InsertLoanApplicationTaskUser(ApplicationId, UserId, Role, Status).Wait();
            // WorkflowId = context.Workflow.Id;
            return(ExecutionResult.Next());
        }
示例#31
0
        public static ExecutionResult ExecuteActions(List <Action> actions)
        {
            ExecutionResult fastBuildResult = ExecutionResult.TasksSucceeded;

            CompilationActions = null;
            LinkerActions      = null;

            if (actions.Count <= 0)
            {
                return(fastBuildResult);
            }

            if (IsAvailable() == false)
            {
                return(ExecutionResult.Unavailable);
            }

            List <Action> unassignedObjects = new List <Action>();
            List <Action> unassignedLinks   = new List <Action>();
            List <Action> miscActions       = actions.Where(a => a.ActionType != ActionType.Compile && a.ActionType != ActionType.Link).ToList();
            Dictionary <Action, BuildComponent> fastbuildActions = new Dictionary <Action, BuildComponent>();

            DeresponsifyActions(actions);

            CompilationActions = GatherActionsObjects(actions.Where(a => a.ActionType == ActionType.Compile), ref unassignedObjects, ref fastbuildActions);
            LinkerActions      = GatherActionsLink(actions.Where(a => a.ActionType == ActionType.Link), ref unassignedLinks, ref fastbuildActions);
            ResolveDependencies(CompilationActions, LinkerActions, fastbuildActions);

            Log.TraceInformation("Actions: " + actions.Count + " - Unassigned: " + unassignedObjects.Count);
            Log.TraceInformation("Misc Actions - FBuild: " + miscActions.Count);
            Log.TraceInformation("Objects - FBuild: " + CompilationActions.Count + " -- Local: " + unassignedObjects.Count);
            var lg = 0;

            if (LinkerActions != null)
            {
                lg = LinkerActions.Count;
            }
            Log.TraceInformation("Link - FBuild: " + lg + " -- Local: " + unassignedLinks.Count);

            if (unassignedLinks.Count > 0)
            {
                throw new Exception("Error, unaccounted for lib! Cannot guarantee there will be no prerequisite issues. Fix it");
            }
            if (unassignedObjects.Count > 0)
            {
                var actionThreadDictionary = new Dictionary <Action, ActionThread>();
                ExecuteLocalActions(unassignedObjects, actionThreadDictionary, unassignedObjects.Count);
            }

            if (FASTBuildConfiguration.UseSinglePassCompilation)
            {
                RunFBuild(BuildStep.CompileAndLink, GenerateFBuildFileString(BuildStep.CompileAndLink, CompilationActions.Concat(LinkerActions).ToList()));
            }
            else
            {
                if (CompilationActions.Any())
                {
                    fastBuildResult = RunFBuild(BuildStep.CompileObjects, GenerateFBuildFileString(BuildStep.CompileObjects, CompilationActions));
                }
                if (fastBuildResult == ExecutionResult.TasksSucceeded)
                {
                    if (LinkerActions != null && LinkerActions.Any())
                    {
                        if (!BuildConfiguration.bFastbuildNoLinking)
                        {
                            fastBuildResult = RunFBuild(BuildStep.Link, GenerateFBuildFileString(BuildStep.Link, LinkerActions));
                        }
                    }
                }
            }
            return(fastBuildResult);
        }
示例#32
0
        static ExecutionResult ExecuteInspectors(InspectionOptions options)
        {
            bool anyFailed = false;

            try
            {
                var dispatch          = new InspectorDispatch();
                var searchService     = new NugetSearchService(options.PackagesRepoUrl, options.NugetConfigPath);
                var inspectionResults = dispatch.Inspect(options, searchService);
                if (inspectionResults != null)
                {
                    foreach (var result in inspectionResults)
                    {
                        try
                        {
                            if (result.ResultName != null)
                            {
                                Console.WriteLine("Inspection: " + result.ResultName);
                            }
                            if (result.Status == InspectionResult.ResultStatus.Success)
                            {
                                Console.WriteLine("Inspection Result: Success");
                                var writer = new InspectionResultJsonWriter(result);
                                writer.Write();
                                Console.WriteLine("Info file created at {0}", writer.FilePath());
                            }
                            else
                            {
                                Console.WriteLine("Inspection Result: Error");
                                if (result.Exception != null)
                                {
                                    Console.WriteLine("Exception:");
                                    Console.WriteLine(result.Exception);
                                    anyFailed = true;
                                }
                            }
                        }
                        catch (Exception e)
                        {
                            Console.WriteLine("Error processing inspection result.");
                            Console.WriteLine(e.Message);
                            Console.WriteLine(e.StackTrace);
                            anyFailed = true;
                        }
                    }
                }
            }
            catch (Exception e)
            {
                Console.WriteLine("Error iterating inspection results.");
                Console.WriteLine(e.Message);
                Console.WriteLine(e.StackTrace);
                anyFailed = true;
            }

            if (anyFailed)
            {
                return(ExecutionResult.Failed());
            }
            else
            {
                return(ExecutionResult.Succeeded());
            }
        }
 public TestsResultResponse(ExecutionResult status, string description)
 {
     this.result = status;
     this.ResultDescription = description;
 }
示例#34
0
 public PreExecutedResolverResult(ExecutionResult executionResult)
 {
     _data       = executionResult.Data;
     _errors     = executionResult.Errors;
     _extensions = executionResult.Extensions;
 }
示例#35
0
 public override ExecutionResult Run(IStepExecutionContext context)
 {
     TaskCTicker++;
     return(ExecutionResult.Next());
 }
示例#36
0
            public async Task CompletesWithResultMessageIfThereIsAnException(ExecutionResult result)
            {
                // Arrange
                var cts = new CancellationTokenSource();
                var runner = new TestableJobRunner(TimeSpan.FromSeconds(5));
                var invocation = TestHelpers.CreateInvocation(Guid.NewGuid(), "test", "test", new Dictionary<string, string>());
                var exception = new Exception("BORK!");
                
                runner.MockDispatcher
                    .Setup(d => d.Dispatch(It.IsAny<InvocationContext>()))
                    .Completes(() =>
                    {
                        runner.VirtualClock.Advance(TimeSpan.FromDays(365)); // Wow this is a long job ;)
                        return new InvocationResult(result, exception);
                    })
                    .Verifiable();

                // Act
                await runner.Dispatch(invocation, cts.Token);

                // Assert
                runner.MockQueue.Verify(q => q.Complete(invocation, result, exception.ToString(), null));
            }
示例#37
0
        private ExecutionResult GetExeResultforAg(BusinessFlow businessFlow, string bfExportedID, ActivitiesGroup activGroup, ref string result, RQMTestPlan testPlan)
        {
            try
            {
                LoginDTO loginData = new LoginDTO()
                {
                    User = ALMCore.DefaultAlmConfig.ALMUserName, Password = ALMCore.DefaultAlmConfig.ALMPassword, Server = ALMCore.DefaultAlmConfig.ALMServerURL
                };

                if (string.IsNullOrEmpty(activGroup.ExternalID))
                {
                    result = "At " + GingerDicser.GetTermResValue(eTermResKey.BusinessFlow) + ": " + businessFlow.Name + " " + GingerDicser.GetTermResValue(eTermResKey.ActivitiesGroup) + ", is missing ExternalID, cannot export RQM TestPlan execution results without External ID";
                    return(null);
                }

                ExecutionResult exeResult = new ExecutionResult {
                    TestPlanExportID = bfExportedID
                };

                List <Activity> relevantActivities = new List <Activity>();
                relevantActivities      = businessFlow.Activities.Where(x => x.ActivitiesGroupID == activGroup.FileName).ToList();
                exeResult.ExecutionStep = new List <ExecutionStep>();

                string txExportID = GetExportedIDString(activGroup.ExternalID, "RQMID");
                string tsExportID = GetExportedIDString(activGroup.ExternalID, "RQMScriptID");
                string erExportID = GetExportedIDString(activGroup.ExternalID, "RQMRecordID");
                if ((activGroup.TestSuiteId != null) && (activGroup.TestSuiteId != string.Empty))
                {
                    // check if test suite execution record is exists per current Test Suite ID
                    // if not exists to create it and than procced to work on just created
                    RQMTestSuite testSuite = testPlan.TestSuites.Where(z => z.RQMID == activGroup.TestSuiteId).FirstOrDefault();
                    if ((testSuite != null) && (testSuite.RQMID != null) && (testSuite.URLPathVersioned != null) &&
                        (testSuite.RQMID != string.Empty) && (testSuite.URLPathVersioned != string.Empty))
                    {
                        try
                        {
                            ResultInfo resultInfo;
                            // check if execution record of testSuite exist. If not - to create it
                            if ((testSuite.TestSuiteExecutionRecord == null) || (testSuite.TestSuiteExecutionRecord.RQMID == null) || (testSuite.TestSuiteExecutionRecord.URLPathVersioned == string.Empty))
                            {
                                testSuite.ACL_TestSuite_Copy = new TestSuite();
                                testSuite.ACL_TestSuite_Copy.TestSuiteName     = testSuite.Name;
                                testSuite.ACL_TestSuite_Copy.TestSuiteExportID = testSuite.RQMID;
                                resultInfo = RQMConnect.Instance.RQMRep.CreateTestSuiteExecutionRecord(loginData, RQMCore.ALMProjectGuid, ALMCore.DefaultAlmConfig.ALMProjectName, RQMCore.ALMProjectGroupName, testSuite.ACL_TestSuite_Copy, bfExportedID, businessFlow.Name.ToString());

                                if (resultInfo.IsSuccess)
                                {
                                    if (testSuite.TestSuiteExecutionRecord == null)
                                    {
                                        testSuite.TestSuiteExecutionRecord = new RQMTestSuiteExecutionRecord();
                                    }
                                    testSuite.TestSuiteExecutionRecord.RQMID            = testSuite.ACL_TestSuite_Copy.TestSuiteExecutionRecordExportID;
                                    testSuite.TestSuiteExecutionRecord.URLPathVersioned = testSuite.ACL_TestSuite_Copy.TestSuiteExecutionRecordExportUri;
                                }
                            }
                            else
                            {
                                testSuite.ACL_TestSuite_Copy = new TestSuite();
                                testSuite.ACL_TestSuite_Copy.TestSuiteName     = testSuite.Name;
                                testSuite.ACL_TestSuite_Copy.TestSuiteExportID = testSuite.RQMID;
                                testSuite.ACL_TestSuite_Copy.TestSuiteExecutionRecordExportID  = testSuite.TestSuiteExecutionRecord.RQMID;
                                testSuite.ACL_TestSuite_Copy.TestSuiteExecutionRecordExportUri = testSuite.TestSuiteExecutionRecord.URLPathVersioned;
                            }

                            // after creating of execution record at RQM and as object at Ginger (or checking that it's exists)
                            // need to create testsuiteLOG on it and add test caseexecution records on it Ginger (the objects at RQM will be created after loop)
                            ACL_Data_Contract.Activity currentActivity = GetTestCaseFromActivityGroup(activGroup);
                            resultInfo = RQMConnect.Instance.RQMRep.CreateExecutionRecordPerActivityWithInTestSuite(loginData, RQMCore.ALMProjectGuid, ALMCore.DefaultAlmConfig.ALMProjectName, RQMCore.ALMProjectGroupName, currentActivity, bfExportedID, businessFlow.Name, testSuite.Name.ToString());
                            if (resultInfo.IsSuccess)
                            {
                                if ((testSuite.TestSuiteExecutionRecord.TestSuiteResults == null) || (testSuite.TestSuiteExecutionRecord.TestSuiteResults.Count == 0) || (testSuite.TestSuiteExecutionRecord.CurrentTestSuiteResult == null))
                                {
                                    testSuite.TestSuiteExecutionRecord.TestSuiteResults       = new ObservableList <RQMTestSuiteResults>();
                                    testSuite.TestSuiteExecutionRecord.CurrentTestSuiteResult = new RQMTestSuiteResults();
                                    testSuite.TestSuiteExecutionRecord.CurrentTestSuiteResult.RQMExecutionRecords = new ObservableList <RQMExecutionRecord>();
                                    testSuite.TestSuiteExecutionRecord.TestSuiteResults.Add(testSuite.TestSuiteExecutionRecord.CurrentTestSuiteResult);
                                }

                                RQMExecutionRecord executionRecord = new RQMExecutionRecord(currentActivity.ExportedTcExecutionRecId.ToString(), currentActivity.ExportedTestScriptId.ToString(), currentActivity.ExportedID.ToString());
                                testSuite.TestSuiteExecutionRecord.CurrentTestSuiteResult.RQMExecutionRecords.Add(executionRecord);
                                testSuite.TestSuiteExecutionRecord.CurrentTestSuiteResult.ACL_TestSuiteLog_Copy.TestSuiteLogExecutionRecords.Add(exeResult);
                                exeResult.ExpectedResultName = currentActivity.EntityName;
                                erExportID = executionRecord.RQMID;
                                currentActivity.ExportedID = long.Parse(executionRecord.RQMID);

                                string atsID = GetExportedIDString(activGroup.ExternalID, "AtsID");
                                if (atsID == "0")
                                {
                                    atsID = string.Empty;
                                }
                                activGroup.ExternalID = "RQMID=" + txExportID + "|RQMScriptID=" + tsExportID + "|RQMRecordID=" + erExportID + "|AtsID=" + atsID;
                            }
                        }
                        catch { }
                    }
                    else
                    {
                    }
                }
                else if (string.IsNullOrEmpty(erExportID) || erExportID.Equals("0") || !testPlan.RQMExecutionRecords.Select(z => z.RQMID).ToList().Contains(erExportID))
                {
                    ResultInfo resultInfo;
                    ACL_Data_Contract.Activity currentActivity = GetTestCaseFromActivityGroup(activGroup);
                    try
                    {
                        // check if executionRecordID exist in RQM but still was not updated in business flow XML
                        RQMExecutionRecord currentExecutionRecord = testPlan.RQMExecutionRecords.Where(y => y.RelatedTestCaseRqmID == txExportID && y.RelatedTestScriptRqmID == tsExportID).ToList().FirstOrDefault();
                        if (currentExecutionRecord != null)
                        {
                            erExportID = currentExecutionRecord.RQMID;
                        }
                        else
                        {
                            // if executionRecord not updated and not exists - so create one in RQM and update BussinesFlow object (this may be not saved due not existed "autosave" functionality)
                            resultInfo = RQMConnect.Instance.RQMRep.CreateExecutionRecordPerActivity(loginData, RQMCore.ALMProjectGuid, ALMCore.DefaultAlmConfig.ALMProjectName, RQMCore.ALMProjectGroupName, currentActivity, bfExportedID, businessFlow.Name);
                            if (!currentActivity.ExportedTcExecutionRecId.Equals("0"))
                            {
                                string atsID = GetExportedIDString(activGroup.ExternalID, "AtsID");
                                if (atsID == "0")
                                {
                                    atsID = string.Empty;
                                }
                                erExportID            = currentActivity.ExportedTcExecutionRecId.ToString();
                                activGroup.ExternalID = "RQMID=" + txExportID + "|RQMScriptID=" + tsExportID + "|RQMRecordID=" + erExportID + "|AtsID=" + atsID;
                                ;
                            }
                        }
                    }
                    catch
                    {
                        Reporter.ToLog(eLogLevel.ERROR, "Failed to create Execution Record Per Activity - " + currentActivity.EntityName);
                    }
                }
                if (string.IsNullOrEmpty(txExportID) || string.IsNullOrEmpty(tsExportID) || string.IsNullOrEmpty(erExportID) || txExportID.Equals("0") || tsExportID.Equals("0") || erExportID.Equals("0"))
                {
                    result = "At " + GingerDicser.GetTermResValue(eTermResKey.BusinessFlow) + ": " + businessFlow.Name + " " + GingerDicser.GetTermResValue(eTermResKey.ActivitiesGroup) + ", is missing ExternalID, cannot export RQM TestPlan execution results without Extrnal ID";
                    return(null);
                }
                exeResult.TestCaseExportID        = txExportID;
                exeResult.TestScriptExportID      = tsExportID;
                exeResult.ExecutionRecordExportID = erExportID;

                int i = 1;
                foreach (Activity act in relevantActivities)
                {
                    ExecutionStep exeStep = new ExecutionStep
                    {
                        StepExpResults = act.Expected,
                        StepOrderId    = i,
                        EntityDesc     = act.ActivityName,
                    };
                    i++;

                    switch (act.Status)
                    {
                    case Amdocs.Ginger.CoreNET.Execution.eRunStatus.Failed:
                        exeStep.StepStatus = ACL_Data_Contract.ExecutoinStatus.Failed;
                        string      errors     = string.Empty;
                        List <IAct> failedActs = act.Acts.Where(x => x.Status == Amdocs.Ginger.CoreNET.Execution.eRunStatus.Failed).ToList();
                        foreach (IAct action in failedActs)
                        {
                            errors += action.Error + Environment.NewLine;
                        }
                        exeStep.StepActualResult = errors;
                        break;

                    case Amdocs.Ginger.CoreNET.Execution.eRunStatus.Passed:
                        exeStep.StepStatus       = ACL_Data_Contract.ExecutoinStatus.Passed;
                        exeStep.StepActualResult = "Passed as expected";
                        break;

                    case Amdocs.Ginger.CoreNET.Execution.eRunStatus.NA:
                        exeStep.StepStatus       = ACL_Data_Contract.ExecutoinStatus.NA;
                        exeStep.StepActualResult = "NA";
                        break;

                    case Amdocs.Ginger.CoreNET.Execution.eRunStatus.Pending:
                        exeStep.StepStatus       = ACL_Data_Contract.ExecutoinStatus.In_Progress;
                        exeStep.StepActualResult = "Was not executed";
                        break;

                    case Amdocs.Ginger.CoreNET.Execution.eRunStatus.Running:
                        exeStep.StepStatus       = ACL_Data_Contract.ExecutoinStatus.In_Progress;
                        exeStep.StepActualResult = "Not Completed";
                        break;

                    case Amdocs.Ginger.CoreNET.Execution.eRunStatus.Skipped:
                        exeStep.StepStatus       = ACL_Data_Contract.ExecutoinStatus.Outscoped;
                        exeStep.StepActualResult = "Skipped";
                        break;

                    case Amdocs.Ginger.CoreNET.Execution.eRunStatus.Blocked:
                        exeStep.StepStatus       = ACL_Data_Contract.ExecutoinStatus.Blocked;
                        exeStep.StepActualResult = "Blocked";
                        break;

                    case Amdocs.Ginger.CoreNET.Execution.eRunStatus.Stopped:
                        exeStep.StepStatus       = ACL_Data_Contract.ExecutoinStatus.Inconclusive;
                        exeStep.StepActualResult = "Stopped";
                        break;
                    }
                    exeResult.ExecutionStep.Add(exeStep);
                }
                return(exeResult);
            }
            catch (Exception ex)
            {
                result = "Unexpected error occurred- " + ex.Message;
                Reporter.ToLog(eLogLevel.ERROR, "Failed to export execution details to RQM/ALM", ex);
                return(null);
            }
        }
	private static string GetExecutionResultOutput (ExecutionResult result)
	{
		string output = "";
		
		if (!string.IsNullOrEmpty (result.output))
		{
			output += "\n";
			output += result.output;
		}
		
		if (!string.IsNullOrEmpty (result.error))
		{
			output += "\n";
			output += result.error;
		}
		
		if (result.exception != null)
		{
			output += "\n";
			output += result.exception.Message;
		}
		
		return output;
	}
 async Task<ExecutionResult> game_restart()
 {
     execresult = ExecutionResult.ERR_NO_ERRORS;
     await Task.Run(() =>
     {
         int addr = 64;
         stackptr = frameptr = 0;
         program_counter = restart_address;
         fileIO.ClearErr(story);
         fileIO.FSeek(story, 64, FSeekOffset.SEEK_SET);
         var buffer = new byte[1024];
         while (!fileIO.FEof(story))
         {
             var readBytes = fileIO.FRead(buffer, 1024, 1, story);
             Array.Copy((byte[])readBytes.Data, 0, memory, addr, readBytes.Length);
             if (readBytes.Length == 0)
                 break;
             addr += 1024;
         }
     });
     return execresult;
 }
示例#40
0
        public async Task InvokeAsync(HttpContext context)
        {
            if (context.WebSockets.IsWebSocketRequest)
            {
                await _next(context);

                return;
            }

            // Handle requests as per recommendation at http://graphql.org/learn/serving-over-http/
            // Inspiration: https://github.com/graphql/express-graphql/blob/master/src/index.js
            var httpRequest  = context.Request;
            var httpResponse = context.Response;

            var writer            = context.RequestServices.GetRequiredService <IDocumentWriter>();
            var cancellationToken = GetCancellationToken(context);

            // GraphQL HTTP only supports GET and POST methods
            bool isGet  = HttpMethods.IsGet(httpRequest.Method);
            bool isPost = HttpMethods.IsPost(httpRequest.Method);

            if (!isGet && !isPost)
            {
                httpResponse.Headers["Allow"] = "GET, POST";
                await WriteErrorResponseAsync(httpResponse, writer, cancellationToken,
                                              $"Invalid HTTP method. Only GET and POST are supported. {DOCS_URL}",
                                              httpStatusCode : 405 // Method Not Allowed
                                              );

                return;
            }

            // Parse POST body
            GraphQLRequest bodyGQLRequest = null;

            GraphQLRequest[] bodyGQLBatchRequest = null;
            if (isPost)
            {
                if (!MediaTypeHeaderValue.TryParse(httpRequest.ContentType, out var mediaTypeHeader))
                {
                    await WriteErrorResponseAsync(httpResponse, writer, cancellationToken, $"Invalid 'Content-Type' header: value '{httpRequest.ContentType}' could not be parsed.");

                    return;
                }

                switch (mediaTypeHeader.MediaType)
                {
                case MediaType.JSON:
                    var deserializationResult = await _deserializer.DeserializeFromJsonBodyAsync(httpRequest, cancellationToken);

                    if (!deserializationResult.IsSuccessful)
                    {
                        await WriteErrorResponseAsync(httpResponse, writer, cancellationToken, "Body text could not be parsed. Body text should start with '{' for normal graphql query or with '[' for batched query.");

                        return;
                    }
                    bodyGQLRequest      = deserializationResult.Single;
                    bodyGQLBatchRequest = deserializationResult.Batch;
                    break;

                case MediaType.GRAPH_QL:
                    bodyGQLRequest = await DeserializeFromGraphBodyAsync(httpRequest.Body);

                    break;

                case MediaType.FORM:
                    var formCollection = await httpRequest.ReadFormAsync();

                    bodyGQLRequest = DeserializeFromFormBody(formCollection);
                    break;

                default:
                    await WriteErrorResponseAsync(httpResponse, writer, cancellationToken, $"Invalid 'Content-Type' header: non-supported media type. Must be of '{MediaType.JSON}', '{MediaType.GRAPH_QL}' or '{MediaType.FORM}'. {DOCS_URL}");

                    return;
                }
            }

            // If we don't have a batch request, parse the query from URL too to determine the actual request to run.
            // Query string params take priority.
            GraphQLRequest gqlRequest = null;

            if (bodyGQLBatchRequest == null)
            {
                var urlGQLRequest = DeserializeFromQueryString(httpRequest.Query);

                gqlRequest = new GraphQLRequest
                {
                    Query         = urlGQLRequest.Query ?? bodyGQLRequest?.Query,
                    Inputs        = urlGQLRequest.Inputs ?? bodyGQLRequest?.Inputs,
                    Extensions    = urlGQLRequest.Extensions ?? bodyGQLRequest?.Extensions,
                    OperationName = urlGQLRequest.OperationName ?? bodyGQLRequest?.OperationName
                };
            }

            // Prepare context and execute
            var userContextBuilder = context.RequestServices.GetService <IUserContextBuilder>();
            var userContext        = userContextBuilder == null
                ? new Dictionary <string, object>() // in order to allow resolvers to exchange their state through this object
                : await userContextBuilder.BuildUserContext(context);

            var executer = context.RequestServices.GetRequiredService <IGraphQLExecuter <TSchema> >();

            // Normal execution with single graphql request
            if (bodyGQLBatchRequest == null)
            {
                var stopwatch = ValueStopwatch.StartNew();
                await RequestExecutingAsync(gqlRequest);

                var result = await ExecuteRequestAsync(gqlRequest, userContext, executer, context.RequestServices, cancellationToken);

                await RequestExecutedAsync(new GraphQLRequestExecutionResult(gqlRequest, result, stopwatch.Elapsed));

                await WriteResponseAsync(httpResponse, writer, cancellationToken, result);
            }
            // Execute multiple graphql requests in one batch
            else
            {
                var executionResults = new ExecutionResult[bodyGQLBatchRequest.Length];
                for (int i = 0; i < bodyGQLBatchRequest.Length; ++i)
                {
                    var gqlRequestInBatch = bodyGQLBatchRequest[i];

                    var stopwatch = ValueStopwatch.StartNew();
                    await RequestExecutingAsync(gqlRequestInBatch, i);

                    var result = await ExecuteRequestAsync(gqlRequestInBatch, userContext, executer, context.RequestServices, cancellationToken);

                    await RequestExecutedAsync(new GraphQLRequestExecutionResult(gqlRequestInBatch, result, stopwatch.Elapsed, i));

                    executionResults[i] = result;
                }

                await WriteResponseAsync(httpResponse, writer, cancellationToken, executionResults);
            }
        }
示例#41
0
 public override ExecutionResult Run(IStepExecutionContext context)
 {
     _myService.DoTheThings();
     return(ExecutionResult.Next());
 }
示例#42
0
        public async Task<ExecutionResult> ExecuteAsync(ExecutionOptions config)
        {
            var metrics = new Metrics();
            metrics.Start(config.OperationName);

            config.FieldMiddleware.ApplyTo(config.Schema);

            var result = new ExecutionResult { Query = config.Query };
            try
            {
                if (!config.Schema.Initialized)
                {
                    using (metrics.Subject("schema", "Initializing schema"))
                    {
                        config.Schema.Initialize();
                    }
                }

                var document = config.Document;
                using (metrics.Subject("document", "Building document"))
                {
                    if (document == null)
                    {
                        document = _documentBuilder.Build(config.Query);
                    }
                }

                result.Document = document;

                var operation = GetOperation(config.OperationName, document);
                result.Operation = operation;
                metrics.SetOperationName(operation?.Name);

                if (config.ComplexityConfiguration != null)
                {
                    using (metrics.Subject("document", "Analyzing complexity"))
                        _complexityAnalyzer.Validate(document, config.ComplexityConfiguration);
                }

                IValidationResult validationResult;
                using (metrics.Subject("document", "Validating document"))
                {
                    validationResult = _documentValidator.Validate(
                        config.Query,
                        config.Schema,
                        document,
                        config.ValidationRules,
                        config.UserContext);
                }

                foreach (var listener in config.Listeners)
                {
                    await listener.AfterValidationAsync(
                            config.UserContext,
                            validationResult,
                            config.CancellationToken)
                        .ConfigureAwait(false);
                }

                if (validationResult.IsValid)
                {
                    var context = BuildExecutionContext(
                        config.Schema,
                        config.Root,
                        document,
                        operation,
                        config.Inputs,
                        config.UserContext,
                        config.CancellationToken,
                        metrics);

                    if (context.Errors.Any())
                    {
                        result.Errors = context.Errors;
                        return result;
                    }

                    using (metrics.Subject("execution", "Executing operation"))
                    {
                        foreach (var listener in config.Listeners)
                        {
                            await listener.BeforeExecutionAsync(config.UserContext, config.CancellationToken).ConfigureAwait(false);
                        }

                        var task = ExecuteOperationAsync(context).ConfigureAwait(false);

                        foreach (var listener in config.Listeners)
                        {
                            await listener.BeforeExecutionAwaitedAsync(config.UserContext, config.CancellationToken).ConfigureAwait(false);
                        }

                        result.Data = await task;

                        foreach (var listener in config.Listeners)
                        {
                            await listener.AfterExecutionAsync(config.UserContext, config.CancellationToken).ConfigureAwait(false);
                        }
                    }

                    if (context.Errors.Any())
                    {
                        result.Errors = context.Errors;
                    }
                }
                else
                {
                    result.Data = null;
                    result.Errors = validationResult.Errors;
                }

                return result;
            }
            catch (Exception exc)
            {
                if (result.Errors == null)
                {
                    result.Errors = new ExecutionErrors();
                }

                result.Data = null;
                result.Errors.Add(new ExecutionError(exc.Message, exc));
                return result;
            }
            finally
            {
                result.Perf = metrics.Finish().ToArray();
            }
        }
示例#43
0
 public XDocument Transform(ExecutionResult executionResult)
 {
     return(new XDocument(
                new XElement("assemblies",
                             executionResult.AssemblyResults.Select(Assembly))));
 }
示例#44
0
        public ExecutionResult ValidateCommand(object commandMessage, ICommandConfiguration commandConfiguration)
        {
            var totalResult = new ExecutionResult();

            IEnumerable<ValidationRuleInstance> ruleInstances = commandConfiguration.GetValidationRules();

            foreach (ValidationRuleInstance instance in ruleInstances)
            {
                if (instance.ShouldApply != null)
                    if (!(bool) instance.ShouldApply.DynamicInvoke(commandMessage))
                        continue;

                Delegate compile = instance.ToCheckExpression.Compile();
                object input = compile.DynamicInvoke(new object[] {commandMessage});
                bool stopProcessing = false;

                if (instance.ArrayRule)
                {
                    var enumerable = (IEnumerable) input;

                    int i = 0;

                    foreach (object item in enumerable)
                    {
                        if (item == null) continue;

                        IValidationRule rule = _ruleFactory.ConstructRule(instance);
                        string result = rule.IsValid(item);

                        bool ruleFailed = result != null;

                        if (ruleFailed)
                        {
                            var indexedUiExpression = new IndexReplacerVisitor(i).Visit(instance.UIAttributeExpression);
                            totalResult.AddMessage(result, instance.ToCheckExpression, (LambdaExpression)indexedUiExpression, instance.ToCompareExpression);

                            if (rule.StopProcessing)
                            {
                                stopProcessing = true;
                                break;
                            }
                        }
                        i++;
                    }
                }
                else
                {
                    IValidationRule rule = _ruleFactory.ConstructRule(instance);

                    if (rule is ICrossReferencedValidationRule)
                    {
                        Delegate toCompareDelegate = instance.ToCompareExpression.Compile();
                        object toCompare = toCompareDelegate.DynamicInvoke(new object[] {commandMessage});
                        ((ICrossReferencedValidationRule) rule).ToCompare = toCompare;
                    }

                    string result = rule.IsValid(input);

                    bool ruleFailed = result != null;

                    if (ruleFailed)
                    {
                        totalResult.AddMessage(result, instance.ToCheckExpression, instance.UIAttributeExpression, instance.ToCompareExpression);

                        if (rule.StopProcessing)
                        {
                            break;
                        }
                    }
                }
                if (stopProcessing)
                    break;
            }

            return totalResult;
        }
示例#45
0
 public void CallSayHelloFunction()
 {
     using (ExecutionResult er = this.Caller.SayHello())
     {
     }
 }
 public override ExecutionResult Run(IStepExecutionContext context)
 {
     Console.WriteLine("goodby!!");
     return(ExecutionResult.Next());
 }
 public override NodeTreeOutput Tick(out ExecutionResult executionResult, ExecutionResult childResult)
 {
     Calculate();
     executionResult = ExecutionResult.Success;
     return(null);
 }
        public ExecutionResult CompileAndExecute(string userId)
        {
            string environmentPath = _root + userId + _ds;

            var progLang = GetProgramingLanguage(environmentPath);

            string languageCompiler = null, sourceFileExtension = null, languageRuntime, runableFileExtension;
            bool   interpretedLanguage = false;

            if (progLang == ProgramingLanguage.CSharp)
            {
                languageCompiler     = "csc";
                sourceFileExtension  = ".cs";
                languageRuntime      = "";
                runableFileExtension = ".exe";
            }
            else if (progLang == ProgramingLanguage.Java)
            {
                languageCompiler     = "javac";
                sourceFileExtension  = ".java";
                languageRuntime      = "java";
                runableFileExtension = "";
            }
            else if (progLang == ProgramingLanguage.Python)
            {
                interpretedLanguage  = true;
                languageRuntime      = "python";
                runableFileExtension = ".py";
            }
            else
            {
                throw new ExecutionServiceException("Unsupported programing language.");
            }

            if (!interpretedLanguage)
            {
                CompileCode(environmentPath, languageCompiler, sourceFileExtension);
            }

            var testCases = GetTestCases(environmentPath);

            foreach (var testCase in testCases)
            {
                ExecuteTestCase(testCase, environmentPath, languageRuntime, runableFileExtension);
            }

            var result = new ExecutionResult
            {
                FailedTestCount     = testCases.Count(t => !t.IsSuccessful),
                SuccessfulTestCount = testCases.Count(t => t.IsSuccessful),
                TestCases           = testCases.Where(t => !t.IsHidden)
                                      .Select(t => new ExecutionTestResult {
                    No = t.No, IsSuccessful = t.IsSuccessful, UserOutput = t.UserOutput
                })
            };

            Console.WriteLine("********************************************************");
            Console.WriteLine("ID : " + userId + " / Score : " + result.SuccessfulTestCount);

            foreach (var testCase in testCases)
            {
                Console.WriteLine("TestCase No : " + testCase.No + " / Argument : " + testCase.Arguments + " / Expected : " + testCase.ExpectedOutput + " / UserOutput : " + testCase.UserOutput + " / isHidden : " + testCase.IsHidden);
            }
            Console.WriteLine("********************************************************");

            return(result);

            #region LOCAL FUNCTION DECLERATIONS

            ProgramingLanguage GetProgramingLanguage(string environmentPath)
            {
                if (!File.Exists(environmentPath + _ds + _environmentSettings))
                {
                    throw new ExecutionServiceException("EnvironmentSettings file does not exist.");
                }
                string progLang = File.ReadAllText(environmentPath + _environmentSettings, Encoding.UTF8);

                ProgramingLanguage result;

                if (!Enum.TryParse(progLang, out result))
                {
                    throw new ExecutionServiceException("Undefined programing language.");
                }

                return(result);
            }

            void CompileCode(string environmentPath, string languageCompiler, string sourceFileExtension)
            {
                var processInfo = new ProcessStartInfo("cmd", "/c cd " + environmentPath + " & " + languageCompiler + " " + _mainFileName + sourceFileExtension)
                {
                    RedirectStandardError  = true,
                    RedirectStandardOutput = true,
                    UseShellExecute        = false,
                    CreateNoWindow         = true
                };

                var process = new Process
                {
                    StartInfo = processInfo
                };

                process.Start();

                DateTime timer = DateTime.Now.AddSeconds(compileTimeLimit);    // 5 saniye çalışma süresi atanıyor.

                while (!process.WaitForExit(200))
                {
                    // calismasi için ayrilan sureyi kontrol ediyor.
                    if (timer < DateTime.Now)
                    {
                        process.Kill();
                        throw new ExecutionServiceException("Code took too long to compile.");
                    }
                }

                string error = process.StandardError.ReadToEnd();

                if (!string.IsNullOrEmpty(error))
                {
                    throw new ExecutionServiceException("Code didn't compile.");
                }

                string output = process.StandardOutput.ReadToEnd();

                if (output.Contains("error"))
                {
                    throw new ExecutionServiceException(output);
                }
            }

            IEnumerable <ExecutionTestCase> GetTestCases(string environmentPath)
            {
                var testCases = new List <ExecutionTestCase>();

                string[] ExecutionTestCases = null;
                if (File.Exists(environmentPath + _ds + _testCases))
                {
                    ExecutionTestCases = File.ReadAllText(environmentPath + _testCases, Encoding.UTF8).Split(new string[] { _spliter }, StringSplitOptions.None);
                }

                for (int i = 0; i < ExecutionTestCases.Length - 1; i += 4)
                {
                    testCases.Add(new ExecutionTestCase
                    {
                        No             = int.Parse(ExecutionTestCases[i]),
                        Arguments      = ExecutionTestCases[i + 1],
                        ExpectedOutput = ExecutionTestCases[i + 2],
                        IsHidden       = bool.Parse(ExecutionTestCases[i + 3]),
                        UserOutput     = null
                    });
                }

                return(testCases);
            }

            void ExecuteTestCase(ExecutionTestCase testCase, string environmentPath, string languageRuntime, string runableFileExtension)
            {
                // create the ProcessStartInfo using "cmd" as the program to be run,
                // and "/c " as the parameters.
                // Incidentally, /c tells cmd that we want it to execute the command that follows,
                // and then exit.
                var runCommand  = languageRuntime + " " + _mainFileName + runableFileExtension;
                var processInfo = new ProcessStartInfo("cmd", "/c " + "cd " + environmentPath + " & " + runCommand + " " + testCase.Arguments);

                // The following commands are needed to redirect the standard output.
                // This means that it will be redirected to the Process.StandardOutput StreamReader.
                processInfo.RedirectStandardOutput = true;
                processInfo.RedirectStandardError  = true;
                processInfo.UseShellExecute        = false;
                // Do not create the black window.
                processInfo.CreateNoWindow = true;
                // Now we create a process, assign its ProcessStartInfo and start it
                Process proc = new Process();

                proc.StartInfo = processInfo;
                proc.Start();

                DateTime timer = DateTime.Now.AddSeconds(executeTimeLimit);    // 5 saniye çalışma süresi atanıyor.

                while (!proc.WaitForExit(250))
                {
                    // calismasi için ayrilan sureyi kontrol ediyor.
                    if (timer < DateTime.Now)
                    {
                        proc.Kill();
                        throw new ExecutionServiceException("Code took too long to execute.");
                        //return kod 5 saniyeden uzun sürdü. *****
                    }
                }

                // Get the output into a string
                string consoleOutput = proc.StandardOutput.ReadToEnd();
                //Console.WriteLine(consoleOutput);
                string error = proc.StandardError.ReadToEnd();

                consoleOutput = consoleOutput.Replace("\r", "");

                if (!string.IsNullOrEmpty(error))
                {
                    testCase.UserOutput = error;
                }
                else
                {
                    testCase.UserOutput = consoleOutput;
                    if (testCase.ExpectedOutput.Equals(consoleOutput))
                    {
                        testCase.IsSuccessful = true;
                    }
                }
            }

            #endregion
        }
示例#49
0
        public void ProcessExecutionResult(WorkflowInstance workflow, WorkflowDefinition def, ExecutionPointer pointer, WorkflowStep step, ExecutionResult result, WorkflowExecutorResult workflowResult)
        {
            pointer.PersistenceData = result.PersistenceData;
            pointer.Outcome         = result.OutcomeValue;
            if (result.SleepFor.HasValue)
            {
                pointer.SleepUntil = _datetimeProvider.Now.ToUniversalTime().Add(result.SleepFor.Value);
                pointer.Status     = PointerStatus.Sleeping;
            }

            if (!string.IsNullOrEmpty(result.EventName))
            {
                pointer.EventName = result.EventName;
                pointer.EventKey  = result.EventKey;
                pointer.Active    = false;
                pointer.Status    = PointerStatus.WaitingForEvent;

                workflowResult.Subscriptions.Add(new EventSubscription()
                {
                    WorkflowId    = workflow.Id,
                    StepId        = pointer.StepId,
                    EventName     = pointer.EventName,
                    EventKey      = pointer.EventKey,
                    SubscribeAsOf = result.EventAsOf
                });
            }

            if (result.Proceed)
            {
                pointer.Active  = false;
                pointer.EndTime = _datetimeProvider.Now.ToUniversalTime();
                pointer.Status  = PointerStatus.Complete;

                foreach (var outcomeTarget in step.Outcomes.Where(x => object.Equals(x.GetValue(workflow.Data), result.OutcomeValue) || x.GetValue(workflow.Data) == null))
                {
                    workflow.ExecutionPointers.Add(_pointerFactory.BuildNextPointer(def, pointer, outcomeTarget));
                }

                _eventPublisher.PublishNotification(new StepCompleted()
                {
                    EventTimeUtc         = _datetimeProvider.Now,
                    Reference            = workflow.Reference,
                    ExecutionPointerId   = pointer.Id,
                    StepId               = step.Id,
                    WorkflowInstanceId   = workflow.Id,
                    WorkflowDefinitionId = workflow.WorkflowDefinitionId,
                    Version              = workflow.Version
                });
            }
            else
            {
                foreach (var branch in result.BranchValues)
                {
                    foreach (var childDefId in step.Children)
                    {
                        workflow.ExecutionPointers.Add(_pointerFactory.BuildChildPointer(def, pointer, childDefId, branch));
                    }
                }
            }
        }
示例#50
0
 public override ExecutionResult Run(IStepExecutionContext context)
 {
     logger.LogInformation("Undoing Task 3");
     return(ExecutionResult.Next());
 }
        private void SetResult(bool bSuccess)
        {
            if (bSuccess)
            {
                if (mRejectAmount == 0)
                    mResult = ExecutionResult.Executed;
                else
                    mResult = (mTrades.Count == 0 && mClosedTrades.Count == 0) ?  ExecutionResult.FullyRejected : ExecutionResult.PartialRejected;
            }
            else
                mResult = ExecutionResult.Canceled;

            if (OrderCompleted != null)
                OrderCompleted(this, EventArgs.Empty);
        }
示例#52
0
        /// <summary>
        /// Reports the outputs of process execution after post process to distinguish between produced outputs and
        /// outputs from cache when assigning affinity for IPC pips
        /// </summary>
        public void ReportProcessExecutionOutputs(ProcessRunnablePip runnableProcess, ExecutionResult executionResult)
        {
            Contract.Assert(runnableProcess.Step == PipExecutionStep.PostProcess);

            if (executionResult.Converged || runnableProcess.Process.IsStartOrShutdownKind)
            {
                // Converged results are cached so they are not considered for as execution outputs
                // Service start/shutdown pip outputs are not considered for IPC pip affinity
                return;
            }

            foreach (var directoryOutput in executionResult.DirectoryOutputs)
            {
                m_executedProcessOutputs.Add(directoryOutput.directoryArtifact);
            }

            foreach (var output in executionResult.OutputContent)
            {
                m_executedProcessOutputs.Add(output.fileArtifact);
            }
        }
 public TestsResultResponse()
 {
     this.result = ExecutionResult.Failed;
     this.ResultDescription = string.Empty;
 }
示例#54
0
        public ascx_WSDL_Creation_and_Execution buildGui()
        {
            var topPanel = this.add_Panel();

            topPanel.insert_Below(100).add_LogViewer();
            //var assemblyInvoke = topPanel.add_Control<O2.External.SharpDevelop.Ascx.ascx_AssemblyInvoke>();
            //assemblyInvoke.loadAssembly("OnlineStorage.dll".assembly());
            //var methodProperties = topPanel.add_DataGridView();

            TestWebServices = topPanel.insert_Above(22).add_ComboBox();

            WsdlLocation = topPanel.insert_Above(22)
                           .add_LabelAndTextAndButton("Load Custom WSDL from location (file or url)", "", "Load", (value) => open(value))
                           .control <TextBox>();
            ExtraWsdlParameres = topPanel.insert_Above(22).add_Label("Extra wsdl.exe parameters").left(WsdlLocation.Left).top(2)
                                 .append_TextBox("").align_Right(topPanel);

            Methods_TreeView           = topPanel.insert_Left(300, "Soap Methods").add_TreeView().sort();
            ExecutionResult            = topPanel.insert_Below(150).add_GroupBox("Web Service Invocation Response Data").add_TextArea();
            ExecutionResult_Properties = ExecutionResult.insert_Right().add_PropertyGrid().helpVisible(false);
            ExecutionResult_TreeView   = ExecutionResult_Properties.insert_Below().add_TreeView();
            ExecuteSoapRequest_Button  = topPanel.insert_Below(40)
                                         .add_Button("Execute Soap request")
                                         .font_bold()
                                         .fill();
            var methodProperties = topPanel.add_GroupBox("Request Data").add_Control <ctrl_ObjectViewer>();

            //methodProperties.showSerializedString().createObjectWhenNull().simpleView();
            methodProperties.createObjectWhenNull().simpleView();

            Methods_TreeView.afterSelect <MethodInfo>(
                (methodInfo) => {
                CurrentMethod = methodInfo;
                "Current Method: {0}".info(CurrentMethod.Name);
                "Current Method: Signature = {0}".info(CurrentMethod.str());
                "Current Method: DeclaringType = {0}".info(CurrentMethod.DeclaringType.FullName);
                SoapParametersObject = methodInfo.create_LiveObject_From_MethodInfo_Parameters("Soap_Invocation_Parameters");
                if (SoapParametersObject.notNull())
                {
                    methodProperties.visible(true);
                    methodProperties.show(SoapParametersObject);
                }
                else
                {
                    methodProperties.visible(false);
                }
                //new O2FormsReflectionASCX().loadMethodInfoParametersInDataGridView(methodInfo, methodProperties);
            });

            ExecuteSoapRequest_Button.onClick(
                () => {
                //var parameters = new O2FormsReflectionASCX().getParameterObjectsFromDataGridColumn(methodProperties, "Value");
                var invocationParameters = new List <object>();
                foreach (var property in SoapParametersObject.type().properties())
                {
                    invocationParameters.add(SoapParametersObject.property(property.Name));
                }

                ExecutionResult.set_Text("[{0}] Executing method : {1}".line().format(DateTime.Now, CurrentMethod.Name));

                var liveObject = CurrentMethod.DeclaringType.ctor();
                ExecutionResult.append_Line("Created dynamic proxy object of type: {0}".format(liveObject));

                try
                {
                    var o2Timer  = new O2Timer("Method execution time: ").start();
                    ResultObject = CurrentMethod.Invoke(liveObject, invocationParameters.ToArray());
                    ExecutionResult.append_Line("Method execution time: {0}".format(o2Timer.stop()));
                    ExecutionResult.append_Line("Method Executed OK, here is the return value:");
                    ExecutionResult.append_Line(ResultObject.str().lineBeforeAndAfter());
                    ExecutionResult_Properties.show(ResultObject);
                    //ExecutionResult_TreeView.xmlShow(ResultObject.serialize());
                }
                //catch(System.Web.Services.Protocols.SoapException ex)
                //{

                //}
                catch (Exception ex)
                {
                    if (ex.InnerException.notNull())
                    {
                        var detail = (ex.InnerException.property("Detail") as System.Xml.XmlElement);
                        if (detail.notNull())
                        {
                            ExecutionResult.append_Line(detail.OuterXml);
                        }
                        ExecutionResult.append_Line(ex.InnerException.Message);
                        ExecutionResult.append_Line(ex.InnerException.StackTrace);
                    }
                    else
                    {
                        ex.log();
                    }
                    //show.info(ex);
                    //ex.details();
                }

                //currentMethod.invoke(parameters);

                ExecutionResult.append_Line("Execution complete");
            });


            Methods_TreeView.insert_Below(20)
            .add_CheckBox("Show Full Method Signatures", 0, 0, (value) => ShowFullMethodSignatures = value)
            .autoSize()
            .parent <Panel>()
            .add_CheckBox("Cache WSDL Dll", 0, 200, (value) => Cache_WSDL_Dll = value)
            .autoSize()
            .check();


            //.append_Link("Delete cached compiled dll", deleteCachedFile);

            ExecutionResult.insert_Below(20)
            .add_Link("View serialized string of response object", 0, 0,
                      () => {
                var serializedResponse = ResultObject.serialize(false);
                if (serializedResponse.notNull())
                {
                    "".showInCodeViewer().set_Text(serializedResponse, "a.xml");
                }
            });


            addScriptingSupport();


            add_TestWebServices();

            return(this);
        }
示例#55
0
        public ExecutionResult HandleMessage(string message, Player player)
        {
            if (player.PlayerFlag != PlayerFlag.LOAD_GAME.ToString())
            {
                player.PlayerMenuContext = player.PlayerFlag.ToString();
                player.PlayerFlag        = PlayerFlag.LOAD_GAME.ToString();
                return(ExecutionResultHelper.SingleMessage("Select a game save to load", GetOptions(player)));
            }
            else if (message == Messages.Return)
            {
                player.PlayerMenuContext2 = "0";
                if (player.PlayerMenuContext == PlayerFlag.GAME_MENU.ToString())
                {
                    return(MessageHandlerHelpers.ReturnToGameMenu(player, ""));
                }
                return(MessageHandlerHelpers.ReturnToMainMenu(player));
            }
            else if (message.StartsWith("<"))
            {
                if (int.TryParse(player.PlayerMenuContext2, out int pageNumber))
                {
                    if (pageNumber <= 0)
                    {
                        pageNumber = 1;
                    }
                    player.PlayerMenuContext2 = "" + (pageNumber - 1);
                }
                else
                {
                    player.PlayerMenuContext2 = "0";
                }
                return(ExecutionResultHelper.SingleMessage("Select a game save to load", GetOptions(player)));
            }
            else if (message.StartsWith(">"))
            {
                if (int.TryParse(player.PlayerMenuContext2, out int pageNumber))
                {
                    if (pageNumber < 0)
                    {
                        pageNumber = 0;
                    }
                    player.PlayerMenuContext2 = "" + (pageNumber + 1);
                }
                else
                {
                    player.PlayerMenuContext2 = "" + player.GameSaves.Count / PageSize;
                }
                return(ExecutionResultHelper.SingleMessage("Select a game save to load", GetOptions(player)));
            }
            else
            {
                var saveIdString = message.Split(' ')[0];
                if (!int.TryParse(saveIdString, out var saveId))
                {
                    return(ExecutionResultHelper.SingleMessage("Invalid save specified", GetOptions(player)));
                }
                var gameSave = _gameSaveService.GetGameSaveById(saveId, player.PlayerId)?.PlayerGameSave;
                if (gameSave == null)
                {
                    return(ExecutionResultHelper.SingleMessage($"Save with ID {saveId} is invalid. Either it doesn't exist, or it doesn't belong to you!", GetOptions(player)));
                }

                player.PlayerMenuContext2 = "0";

                player.ActiveGameSave.GameName     = gameSave.GameName;
                player.ActiveGameSave.GameSaveData = gameSave.GameSaveData.Select(a => new PlayerGameSaveData {
                    Name = a.Name, Value = a.Value
                }).ToList();
                player.ActiveGameSave.StateId    = gameSave.StateId;
                player.ActiveGameSave.FrameStack = gameSave.FrameStack.Select(a => new PlayerFrameStack
                {
                    CreatedDate   = a.CreatedDate,
                    FunctionName  = a.FunctionName,
                    ReturnStateId = a.ReturnStateId,
                    Save          = player.ActiveGameSave,
                    SaveId        = player.ActiveGameSave.SaveId
                }).ToList();

                player.PlayerFlag = PlayerFlag.IN_GAME.ToString();
                var games       = _gameStore.ListGames();
                var playerState = player.ActiveGameSave;
                var gameFound   = games.Where(a => a.GameName == playerState.GameName).FirstOrDefault();
                var state       = gameFound.FindStateById(playerState.StateId);
                var execResult  = new ExecutionResult
                {
                    MessagesToShow = new List <MessageResult> {
                        new MessageResult {
                            Message = _textParsing.ParseText(playerState, state.StateText)
                        }
                    },
                    OptionsToShow = _gameProcessor.GetCurrentOptions(playerState, gameFound, state)
                };

                execResult.OptionsToShow.Add("-Menu-");
                return(execResult);
            }
        }
示例#56
0
 public override ExecutionResult Run(IStepExecutionContext context)
 {
     TaskATicker++;
     return(ExecutionResult.Outcome(true));
 }
示例#57
0
            public async Task EnqueuesARescheduleIfTheResultRequestsIt(ExecutionResult result)
            {
                // Arrange
                var cts = new CancellationTokenSource();
                var runner = new TestableJobRunner(TimeSpan.FromSeconds(5));
                var invocation = TestHelpers.CreateInvocation(Guid.NewGuid(), "test", "test", new Dictionary<string, string>());
                var repeat = TestHelpers.CreateInvocation(Guid.NewGuid(), "test", "test", new Dictionary<string,string>());
                
                runner.MockDispatcher
                    .Setup(d => d.Dispatch(It.IsAny<InvocationContext>()))
                    .Completes(new InvocationResult(result, result == ExecutionResult.Faulted ? new Exception() : null, TimeSpan.FromDays(365)))
                    .Verifiable();
                runner.MockQueue
                    .Setup(q => q.Enqueue("test", Constants.Source_RepeatingJob, It.IsAny<Dictionary<string, string>>(), TimeSpan.FromDays(365), null))
                    .Completes(repeat);

                // Act
                await runner.Dispatch(invocation, cts.Token);

                // Assert
                runner.MockQueue.Verify(q => q.Enqueue(invocation.Job, Constants.Source_RepeatingJob, invocation.Payload, TimeSpan.FromDays(365), null));
            }
示例#58
0
        public static ExecutionResult ExecuteActions(List <Action> Actions)
        {
            ExecutionResult SNDBSResult = ExecutionResult.TasksSucceeded;

            if (Actions.Count > 0)
            {
                string SCERoot         = Environment.GetEnvironmentVariable("SCE_ROOT_DIR");
                string SNDBSExecutable = Path.Combine(SCERoot, "Common/SN-DBS/bin/dbsbuild.exe");

                // Check that SN-DBS is available
                bool bSNDBSExists = File.Exists(SNDBSExecutable);
                if (bSNDBSExists == false)
                {
                    return(ExecutionResult.Unavailable);
                }

                // Use WMI to figure out physical cores, excluding hyper threading.
                int NumCores = 0;
                if (!Utils.IsRunningOnMono)
                {
                    try
                    {
                        using (var Mos = new System.Management.ManagementObjectSearcher("Select * from Win32_Processor"))
                        {
                            var MosCollection = Mos.Get();
                            foreach (var Item in MosCollection)
                            {
                                NumCores += int.Parse(Item["NumberOfCores"].ToString());
                            }
                        }
                    }
                    catch (Exception Ex)
                    {
                        Log.TraceWarning("Unable to get the number of Cores: {0}", Ex.ToString());
                        Log.TraceWarning("Falling back to processor count.");
                    }
                }
                // On some systems this requires a hot fix to work so we fall back to using the (logical) processor count.
                if (NumCores == 0)
                {
                    NumCores = System.Environment.ProcessorCount;
                }
                // The number of actions to execute in parallel is trying to keep the CPU busy enough in presence of I/O stalls.
                MaxActionsToExecuteInParallel = 0;
                // The CPU has more logical cores than physical ones, aka uses hyper-threading.
                if (NumCores < System.Environment.ProcessorCount)
                {
                    MaxActionsToExecuteInParallel = (int)(NumCores * BuildConfiguration.ProcessorCountMultiplier);
                }
                // No hyper-threading. Only kicking off a task per CPU to keep machine responsive.
                else
                {
                    MaxActionsToExecuteInParallel = NumCores;
                }
                MaxActionsToExecuteInParallel = Math.Min(MaxActionsToExecuteInParallel, BuildConfiguration.MaxProcessorCount);

                JobNumber = 1;
                Dictionary <Action, ActionThread> ActionThreadDictionary = new Dictionary <Action, ActionThread>();

                while (true)
                {
                    bool bUnexecutedActions = false;
                    foreach (Action Action in Actions)
                    {
                        ActionThread ActionThread        = null;
                        bool         bFoundActionProcess = ActionThreadDictionary.TryGetValue(Action, out ActionThread);
                        if (bFoundActionProcess == false)
                        {
                            bUnexecutedActions = true;
                            ExecutionResult CompileResult = ExecuteActions(Actions, ActionThreadDictionary);
                            if (CompileResult != ExecutionResult.TasksSucceeded)
                            {
                                return(ExecutionResult.TasksFailed);
                            }
                            break;
                        }
                    }

                    if (bUnexecutedActions == false)
                    {
                        break;
                    }
                }

                Log.WriteLineIf(BuildConfiguration.bLogDetailedActionStats, TraceEventType.Information, "-------- Begin Detailed Action Stats ----------------------------------------------------------");
                Log.WriteLineIf(BuildConfiguration.bLogDetailedActionStats, TraceEventType.Information, "^Action Type^Duration (seconds)^Tool^Task^Using PCH");

                double TotalThreadSeconds = 0;

                // Check whether any of the tasks failed and log action stats if wanted.
                foreach (KeyValuePair <Action, ActionThread> ActionProcess in ActionThreadDictionary)
                {
                    Action       Action       = ActionProcess.Key;
                    ActionThread ActionThread = ActionProcess.Value;

                    // Check for pending actions, preemptive failure
                    if (ActionThread == null)
                    {
                        SNDBSResult = ExecutionResult.TasksFailed;
                        continue;
                    }
                    // Check for executed action but general failure
                    if (ActionThread.ExitCode != 0)
                    {
                        SNDBSResult = ExecutionResult.TasksFailed;
                    }
                    // Log CPU time, tool and task.
                    double ThreadSeconds = Action.Duration.TotalSeconds;

                    Log.WriteLineIf(BuildConfiguration.bLogDetailedActionStats,
                                    TraceEventType.Information,
                                    "^{0}^{1:0.00}^{2}^{3}^{4}",
                                    Action.ActionType.ToString(),
                                    ThreadSeconds,
                                    Path.GetFileName(Action.CommandPath),
                                    Action.StatusDescription,
                                    Action.bIsUsingPCH);

                    // Update statistics
                    switch (Action.ActionType)
                    {
                    case ActionType.BuildProject:
                        UnrealBuildTool.TotalBuildProjectTime += ThreadSeconds;
                        break;

                    case ActionType.Compile:
                        UnrealBuildTool.TotalCompileTime += ThreadSeconds;
                        break;

                    case ActionType.CreateAppBundle:
                        UnrealBuildTool.TotalCreateAppBundleTime += ThreadSeconds;
                        break;

                    case ActionType.GenerateDebugInfo:
                        UnrealBuildTool.TotalGenerateDebugInfoTime += ThreadSeconds;
                        break;

                    case ActionType.Link:
                        UnrealBuildTool.TotalLinkTime += ThreadSeconds;
                        break;

                    default:
                        UnrealBuildTool.TotalOtherActionsTime += ThreadSeconds;
                        break;
                    }

                    // Keep track of total thread seconds spent on tasks.
                    TotalThreadSeconds += ThreadSeconds;
                }

                Log.TraceInformation("-------- End Detailed Actions Stats -----------------------------------------------------------");

                // Log total CPU seconds and numbers of processors involved in tasks.
                Log.WriteLineIf(BuildConfiguration.bLogDetailedActionStats || BuildConfiguration.bPrintDebugInfo,
                                TraceEventType.Information, "Cumulative thread seconds ({0} processors): {1:0.00}", System.Environment.ProcessorCount, TotalThreadSeconds);
            }
            return(SNDBSResult);
        }
	private static ExecutionResult Execute (string command, params string[] arguments)
	{
		Process process = new Process ();
		process.EnableRaisingEvents = true;
		process.StartInfo.FileName = command;
		process.StartInfo.Arguments = string.Join (" ", arguments, 0, arguments.Length);
		
		// flags to be able to read build script output
		process.StartInfo.RedirectStandardOutput = true;
		process.StartInfo.RedirectStandardError = true;
		process.StartInfo.UseShellExecute = false;
		
		ExecutionResult result = new ExecutionResult ();
		
		try
		{
			process.Start ();
			process.WaitForExit ();
			
			result.output = process.StandardOutput.ReadToEnd ();
			result.error = process.StandardError.ReadToEnd ();
			result.success = string.IsNullOrEmpty (result.error);
		}
		catch (System.Exception exception)
		{
			result.exception = exception;
			result.success = false;
		}
		
		return result;
	}
示例#60
0
        internal static ExecutionResult ExecuteLocalActions(List <Action> InLocalActions, Dictionary <Action, ActionThread> InActionThreadDictionary, int TotalNumJobs)
        {
            // Time to sleep after each iteration of the loop in order to not busy wait.
            const float LoopSleepTime = 0.1f;

            ExecutionResult LocalActionsResult = ExecutionResult.TasksSucceeded;

            while (true)
            {
                // Count the number of pending and still executing actions.
                int NumUnexecutedActions = 0;
                int NumExecutingActions  = 0;
                foreach (Action Action in InLocalActions)
                {
                    ActionThread ActionThread        = null;
                    bool         bFoundActionProcess = InActionThreadDictionary.TryGetValue(Action, out ActionThread);
                    if (bFoundActionProcess == false)
                    {
                        NumUnexecutedActions++;
                    }
                    else if (ActionThread != null)
                    {
                        if (ActionThread.bComplete == false)
                        {
                            NumUnexecutedActions++;
                            NumExecutingActions++;
                        }
                    }
                }

                // If there aren't any pending actions left, we're done executing.
                if (NumUnexecutedActions == 0)
                {
                    break;
                }

                // If there are fewer actions executing than the maximum, look for pending actions that don't have any outdated
                // prerequisites.
                foreach (Action Action in InLocalActions)
                {
                    ActionThread ActionProcess       = null;
                    bool         bFoundActionProcess = InActionThreadDictionary.TryGetValue(Action, out ActionProcess);
                    if (bFoundActionProcess == false)
                    {
                        if (NumExecutingActions < Math.Max(1, MaxActionsToExecuteInParallel))
                        {
                            // Determine whether there are any prerequisites of the action that are outdated.
                            bool bHasOutdatedPrerequisites = false;
                            bool bHasFailedPrerequisites   = false;
                            foreach (FileItem PrerequisiteItem in Action.PrerequisiteItems)
                            {
                                if (PrerequisiteItem.ProducingAction != null && InLocalActions.Contains(PrerequisiteItem.ProducingAction))
                                {
                                    ActionThread PrerequisiteProcess       = null;
                                    bool         bFoundPrerequisiteProcess = InActionThreadDictionary.TryGetValue(PrerequisiteItem.ProducingAction, out PrerequisiteProcess);
                                    if (bFoundPrerequisiteProcess == true)
                                    {
                                        if (PrerequisiteProcess == null)
                                        {
                                            bHasFailedPrerequisites = true;
                                        }
                                        else if (PrerequisiteProcess.bComplete == false)
                                        {
                                            bHasOutdatedPrerequisites = true;
                                        }
                                        else if (PrerequisiteProcess.ExitCode != 0)
                                        {
                                            bHasFailedPrerequisites = true;
                                        }
                                    }
                                    else
                                    {
                                        bHasOutdatedPrerequisites = true;
                                    }
                                }
                            }

                            // If there are any failed prerequisites of this action, don't execute it.
                            if (bHasFailedPrerequisites)
                            {
                                // Add a null entry in the dictionary for this action.
                                InActionThreadDictionary.Add(Action, null);
                            }
                            // If there aren't any outdated prerequisites of this action, execute it.
                            else if (!bHasOutdatedPrerequisites)
                            {
                                ActionThread ActionThread = new ActionThread(Action, JobNumber, TotalNumJobs);
                                ActionThread.Run();

                                InActionThreadDictionary.Add(Action, ActionThread);

                                NumExecutingActions++;
                                JobNumber++;
                            }
                        }
                    }
                }

                System.Threading.Thread.Sleep(TimeSpan.FromSeconds(LoopSleepTime));
            }

            return(LocalActionsResult);
        }