public virtual void BindData(ScreenObjectGeneratorOptions options) { ignoreLabels.DataBindings.Add("Checked", options, CodePath.Get(CodePath.New <ScreenObjectGeneratorOptions>().IgnoreLabels), false, DataSourceUpdateMode.OnPropertyChanged); namespaceText.DataBindings.Add("Text", options, CodePath.Get(CodePath.New <ScreenObjectGeneratorOptions>().Namespace), false, DataSourceUpdateMode.OnPropertyChanged); }
/// <summary> /// Call VSCode with arguments /// </summary> static void CallVSCode(string args) { System.Diagnostics.Process proc = new System.Diagnostics.Process(); if (!VSCodeExists(CodePath)) { PrintNotFound(CodePath); return; } #if UNITY_EDITOR_OSX proc.StartInfo.FileName = "open"; // Check the path to see if there is "Insiders" if (CodePath.Contains("Insiders")) { proc.StartInfo.Arguments = " -n -b \"com.microsoft.VSCodeInsiders\" --args " + args.Replace(@"\", @"\\"); } else { proc.StartInfo.Arguments = " -n -b \"com.microsoft.VSCode\" --args " + args.Replace(@"\", @"\\"); } proc.StartInfo.UseShellExecute = false; #elif UNITY_EDITOR_WIN proc.StartInfo.FileName = CodePath; proc.StartInfo.Arguments = args; proc.StartInfo.UseShellExecute = false; #else proc.StartInfo.FileName = CodePath; proc.StartInfo.Arguments = args.Replace(@"\", @"\\"); proc.StartInfo.UseShellExecute = false; #endif proc.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden; proc.StartInfo.CreateNoWindow = true; proc.StartInfo.RedirectStandardOutput = true; proc.Start(); }
public void ConcatNew_ConcatPartial_ShouldConcatFullChain(params string[][] parms) { // arrange var extraPath = new CodePath(); var sut = new CodePath(); foreach (var name in parms[0]) { var mockedMethod = Mock.Create <Method>(); Mock.Arrange(() => mockedMethod.FullName).Returns(name); sut.AddLast(mockedMethod); } foreach (var name in parms[1]) { var mockedMethod = Mock.Create <Method>(); Mock.Arrange(() => mockedMethod.FullName).Returns(name); extraPath.AddLast(mockedMethod); } // form expected final path var expected = parms[0].Concat(parms[1].Skip(2)); // act var newSut = sut.ConcatNew(extraPath.GetSubPaths().ToList()[1]); // assert Assert.Equal(parms[0].Length + parms[1].Length - 2, newSut.Count()); Assert.Equal(parms[0].Length + parms[1].Length - 2, newSut.Length); Assert.Equal(expected, newSut.Select(x => x.FullName)); }
public void ConcatNew_ShouldMaintainOldChain(params string[] parms) { // arrange var extraPath = new CodePath(); var sut = new CodePath(); foreach (var name in parms) { var mockedMethod = Mock.Create <Method>(); Mock.Arrange(() => mockedMethod.FullName).Returns(name); extraPath.AddLast(mockedMethod); sut.AddLast(mockedMethod); } // act sut.ConcatNew(extraPath); // assert var actualCount = sut.Count(); Assert.Equal(parms.Length, actualCount); Assert.Equal(parms.Length, sut.Length); var index = 0; foreach (var method in sut) { Assert.Equal(parms[index++], method.FullName); } }
public void AddLastNew_AddMultiple_ShouldAddAllNodes(params string[] parms) { // arrange var sut = new CodePath(); var list = new List <Method>(); foreach (var name in parms) { var mockedMethod = Mock.Create <Method>(); Mock.Arrange(() => mockedMethod.FullName).Returns(name); list.Add(mockedMethod); } // act foreach (var method in list) { sut = sut.AddLastNew(method); } // assert Assert.Equal(parms.Length, sut.Count()); Assert.Equal(parms.Length, sut.Length); foreach (var pair in sut.Zip(parms, (x, y) => new KeyValuePair <Method, String>(x, y))) { Assert.Equal(pair.Value, pair.Key.FullName); } }
public void Equals_EqualPaths_ShouldReturnTrue(params string[] parms) { // arrange var extraPath = new CodePath(); var sut1 = new CodePath(); foreach (var name in parms) { var mockedMethod = Mock.Create <Method>(); Mock.Arrange(() => mockedMethod.FullName).Returns(name); sut1.AddLast(mockedMethod); } var sut2 = new CodePath(); foreach (var name in parms) { var mockedMethod = Mock.Create <Method>(); Mock.Arrange(() => mockedMethod.FullName).Returns(name); sut2.AddLast(mockedMethod); } // act var actual = sut1.Equals(sut2); // assert Assert.Equal(parms.Length, sut1.Length); Assert.Equal(parms.Length, sut2.Length); Assert.True(actual); }
static ListViewEvent() { CodePath.New <ListView>().Select(0); select = CodePath.Last; CodePath.New <ListView>().TryUnSelectAll(); tryUnSelectAll = CodePath.Last; }
public virtual void BindData(Applications applicationsWithWindow) { applications.DataSource = applicationsWithWindow; applications.DisplayMember = CodePath.Get(CodePath.New <Application>().Name); windows.DisplayMember = CodePath.Get(CodePath.New <DummyWindow>().Title); windowTabs.DisplayMember = CodePath.Get(CodePath.New <Tab>().PrimaryIdentification); }
static TreeNodeClickedEvent() { CodePath.New <TreeNode>().Collapse(); collapseEventName = CodePath.Last; CodePath.New <TreeNode>().Expand(); expandEventName = CodePath.Last; }
public virtual void BindData(RecordingOptions recordingOptions) { core.DataBindings.Add("Checked", recordingOptions, CodePath.Get(CodePath.New <RecordingOptions>().Core), false, DataSourceUpdateMode.OnPropertyChanged); screenRepository.DataBindings.Add("Checked", recordingOptions, CodePath.Get(CodePath.New <RecordingOptions>().ScreenRepository), false, DataSourceUpdateMode.OnPropertyChanged); bulkText.DataBindings.Add("Checked", recordingOptions, CodePath.Get(CodePath.New <RecordingOptions>().BulkText), false, DataSourceUpdateMode.OnPropertyChanged); }
public CodePath ToCodePath() { var path = new CodePath(); var idList = this.Ids.Split(','); foreach (var id in idList) { path.AddLast(new MockMethod(int.Parse(id))); } return(path); }
public void GetSubPaths_SubPathsHaveValidProperties(params string[] parms) { // arrange var sut = new CodePath(); foreach (var name in parms) { var mockedMethod = Mock.Create <Method>(); Mock.Arrange(() => mockedMethod.FullName).Returns(name); sut.AddLast(mockedMethod); } // act var subPathsList = sut.GetSubPaths().ToList(); // assert for (int i = 0; i < subPathsList.Count; i++) { var currentPath = subPathsList[i]; Assert.Equal(sut.Length - i - 1, currentPath.Length); Assert.Equal(sut.ElementAt(i + 1), currentPath.FirstMethod); Assert.Equal(sut.LastMethod, currentPath.LastMethod); } }
public void AddLast_AddMultiple_ShouldHaveProperLength(params string[] parms) { // arrange var sut = new CodePath(); var list = new List <Method>(); foreach (var name in parms) { var mockedMethod = Mock.Create <Method>(); Mock.Arrange(() => mockedMethod.FullName).Returns(name); list.Add(mockedMethod); } // act foreach (var method in list) { sut.AddLast(method); } Assert.Equal(parms.Length, sut.Count()); // assert Assert.Equal(parms.Length, sut.Length); }
private bool IsCodePathAnIfPath(CodePath path) { HLInstruction instruction = path.GetFirstInstruction(); bool foundOneIf = false; while (instruction != null) { if (instruction.IsConditionalBranch && instruction.ProcessedStackValue != null) { foundOneIf = true; } else { if (instruction.ProcessedStackValue != null) { return(false); } } instruction = instruction.GetNextInstruction(); } return(foundOneIf); }
static ListControlEvent() { CodePath.New <ComboBox>().Select(null); actionName = CodePath.Last; }
static TextBoxEvent() { textAction = CodePath.Get(CodePath.New <TextBox>().Text); CodePath.New <TextBox>().BulkText = null; bulkTextAction = CodePath.Last; }
static TreeNodeSelectEvent() { CodePath.New <TreeNode>().Select(); selectEventName = CodePath.Last; }
static TabEvent() { CodePath.New <Tab>().SelectTabPage(null); action = CodePath.Last; }
private void ProcessCodePath(TextWriter writer, CodePath path, string indent) { HLInstruction instruction = path.GetFirstInstruction(); while (instruction != null) { Annotate(writer, indent, instruction); if (instruction.UnconditionalBranch) { // Not used } else if (instruction.IsConditionalBranch) { if (_nextIfIsAnElseIf) { writer.Write(string.Format("{0}else if", indent)); _nextIfIsAnElseIf = false; } else { writer.Write(string.Format("{0}if", indent)); } writer.WriteLine(string.Format(" ({0})", instruction.ProcessedStackValue)); writer.WriteLine(indent + "{"); ProcessCodePath(writer, instruction.BranchCodesPaths[instruction.DefaultConditional], indent + " "); writer.WriteLine(indent + "}"); if (instruction.BranchCodesPaths.ContainsKey(!instruction.DefaultConditional)) { CodePath elsePath = instruction.BranchCodesPaths[!instruction.DefaultConditional]; if (elsePath.StartInstruction != null) { if (IsCodePathAnIfPath(elsePath)) { _nextIfIsAnElseIf = true; ProcessCodePath(writer, elsePath, indent); } else { writer.WriteLine(indent + "else"); writer.WriteLine(indent + "{"); ProcessCodePath(writer, elsePath, indent + " "); writer.WriteLine(indent + "}"); } } } } else if (instruction.IsSwitchBranch) { // Do switch cases ever fall through?? I'm assuming they don't here! writer.WriteLine(indent + string.Format("switch ({0})", instruction.ProcessedStackValue)); writer.WriteLine(indent + "{"); // Keep track of code paths are have already outputted to keep // track of offsets that lead to the same codepath var swDonePaths = new List <CodePath>(); foreach (var item in instruction.BranchCodesPaths) { if (swDonePaths.Contains(item.Value)) { continue; } foreach (var item2 in instruction.BranchCodesPaths) { // O(n^2) loop here, there's probably a better way to optimize it if (item2.Value == item.Value) { if (item2.Key.GetType() == typeof(int)) { writer.WriteLine(string.Format("{0} case {1}:", indent, LiteralFormatter.FormatInteger((int)item2.Key))); } else { writer.WriteLine(string.Format("{0} default:", indent)); } } } writer.WriteLine(indent + " {"); ProcessCodePath(writer, item.Value, indent + " "); if (item.Value.EndInstruction == null || !item.Value.EndInstruction.ExitFunction) { writer.WriteLine(indent + " break;"); } writer.WriteLine(indent + " }"); swDonePaths.Add(item.Value); } writer.WriteLine(indent + "}"); } else if (instruction.LoopCodePath != null) { // First of a loop instruction (hopefully, someday, this will be extracted out by the ProgramAnalyzer) // Can we ever break out of a loop? I assume we can't here! while (!instruction.IsConditionalBranch) { instruction = instruction.NextInstruction; Annotate(writer, indent, instruction); } writer.WriteLine(indent + string.Format("while ({0})", instruction.ProcessedStackValue)); writer.WriteLine(indent + "{"); ProcessCodePath(writer, instruction.BranchCodesPaths[true], indent + " "); writer.WriteLine(indent + "}"); } else { WriteInstruction(writer, instruction, indent); } instruction = instruction.NextInstruction; } }
private void ProcessCodePath(TextWriter writer, CodePath path, string indent) { HLInstruction instruction = path.GetFirstInstruction(); while (instruction != null) { if (instruction.IsConditionalBranch) { writer.WriteLine(string.Format("{0}.if{1}", indent, instruction.DefaultConditional ? "true" : "false")); ProcessCodePath(writer, instruction.BranchCodesPaths[instruction.DefaultConditional], indent + " "); if (instruction.BranchCodesPaths.ContainsKey(!instruction.DefaultConditional)) { CodePath elsePath = instruction.BranchCodesPaths[!instruction.DefaultConditional]; if (elsePath.StartInstruction != null) { writer.WriteLine(indent + ".else"); ProcessCodePath(writer, elsePath, indent + " "); } } writer.WriteLine(indent + ".endif"); } else if (instruction.IsSwitchBranch) { // Do switch cases ever fall through?? I'm assuming they don't here! writer.WriteLine(indent + ".switch"); // Keep track of code paths are have already outputted to keep // track of offsets that lead to the same codepath var swDonePaths = new List <CodePath>(); foreach (var item in instruction.BranchCodesPaths) { if (swDonePaths.Contains(item.Value)) { continue; } foreach (var item2 in instruction.BranchCodesPaths) { // O(n^2) loop here, there's probably a better way to optimize it if (item2.Value == item.Value) { if (item2.Key.GetType() == typeof(int)) { writer.WriteLine(string.Format("{0} .case {1}", indent, item2.Key)); } else { writer.WriteLine(string.Format("{0} .default", indent, item2.Key)); } } } ProcessCodePath(writer, item.Value, indent + " "); if (item.Value.EndInstruction == null || !item.Value.EndInstruction.ExitFunction) { writer.WriteLine(indent + " .break"); } swDonePaths.Add(item.Value); } writer.WriteLine(indent + ".endswitch"); } else if (instruction.LoopCodePath != null) { // First of a loop instruction (hopefully, someday, this will be extracted out by the ProgramAnalyzer) // Can we ever break out of a loop? I assume we can't here! writer.WriteLine(indent + ".while"); instruction = WriteLoopConditional(writer, instruction, indent + " "); writer.WriteLine(indent + ".do"); ProcessCodePath(writer, instruction.BranchCodesPaths[true], indent + " "); writer.WriteLine(indent + ".endwhile"); } else { WriteInstruction(writer, instruction, indent); } instruction = instruction.GetNextInstruction(); } }
static UIItemClickEvent() { CodePath.New <UIItem>().Click(); actionName = CodePath.Last; }
/// <summary> /// LUA结构支持 /// </summary> /// <returns></returns> public override void GetLuaStruct(StringBuilder code) { base.GetLuaStruct(code); int idx; idx = 0; code.AppendLine("['ApiItems'] ={"); foreach (var val in ApiItems) { if (idx++ > 0) { code.Append(','); } code.AppendLine($@"{val.GetLuaStruct()}"); } code.AppendLine("},"); idx = 0; code.AppendLine("['Entities'] ={"); foreach (var val in Entities) { if (idx++ > 0) { code.Append(','); } code.AppendLine($@"{val.GetLuaStruct()}"); } code.AppendLine("},"); code.AppendLine($@"['ReadOnly'] ={(ReadOnly.ToString().ToLower())},"); if (!string.IsNullOrWhiteSpace(DataBaseObjectName)) { code.AppendLine($@"['DataBaseObjectName'] = '{DataBaseObjectName.ToLuaString()}',"); } else { code.AppendLine($@"['DataBaseObjectName'] = nil,"); } if (!string.IsNullOrWhiteSpace(NameSpace)) { code.AppendLine($@"['NameSpace'] = '{NameSpace.ToLuaString()}',"); } else { code.AppendLine($@"['NameSpace'] = nil,"); } if (!string.IsNullOrWhiteSpace(PagePath)) { code.AppendLine($@"['PagePath'] = '{PagePath.ToLuaString()}',"); } else { code.AppendLine($@"['PagePath'] = nil,"); } if (!string.IsNullOrWhiteSpace(BusinessPath)) { code.AppendLine($@"['BusinessPath'] = '{BusinessPath.ToLuaString()}',"); } else { code.AppendLine($@"['BusinessPath'] = nil,"); } if (!string.IsNullOrWhiteSpace(ClientCsPath)) { code.AppendLine($@"['ClientCsPath'] = '{ClientCsPath.ToLuaString()}',"); } else { code.AppendLine($@"['ClientCsPath'] = nil,"); } if (!string.IsNullOrWhiteSpace(ModelPath)) { code.AppendLine($@"['ModelPath'] = '{ModelPath.ToLuaString()}',"); } else { code.AppendLine($@"['ModelPath'] = nil,"); } if (!string.IsNullOrWhiteSpace(CodePath)) { code.AppendLine($@"['CodePath'] = '{CodePath.ToLuaString()}',"); } else { code.AppendLine($@"['CodePath'] = nil,"); } code.AppendLine($@"['DbType'] ='{DbType}',"); if (!string.IsNullOrWhiteSpace(DbHost)) { code.AppendLine($@"['DbHost'] = '{DbHost.ToLuaString()}',"); } else { code.AppendLine($@"['DbHost'] = nil,"); } if (!string.IsNullOrWhiteSpace(DbSoruce)) { code.AppendLine($@"['DbSoruce'] = '{DbSoruce.ToLuaString()}',"); } else { code.AppendLine($@"['DbSoruce'] = nil,"); } if (!string.IsNullOrWhiteSpace(DbPassWord)) { code.AppendLine($@"['DbPassWord'] = '******',"); } else { code.AppendLine($@"['DbPassWord'] = nil,"); } if (!string.IsNullOrWhiteSpace(DbUser)) { code.AppendLine($@"['DbUser'] = '******',"); } else { code.AppendLine($@"['DbUser'] = nil,"); } }
protected override string ActionName(EventOption eventOption) { CodePath.New <RadioButton>().Select(); return(CodePath.Last); }