private static void TestEvents() { using (var proxy = new GeneratedTest("http://localhost:3000/endpoint/1.0")) { int n1 = 0; int n2 = 0; int n3 = 0; proxy.TestEvent2 += (sender, data) => { Console.WriteLine("event2:{0}", data.Data[0].width); n2++; }; proxy.TestEvent += (sender, data) => { Console.WriteLine("event1:{0}", data.Data); n1++; }; proxy.TestEvent3 += (sender, data) => { Console.WriteLine("event3:{0}", data.Data); n3++; }; for (long i = 0, prev = i; i < 20; i++) { Console.WriteLine(prev = proxy.UseWS().Sum(i, prev).Result); } Thread.Sleep(10000); Console.WriteLine("{0}, {1}, {2}", n1, n2, n3); } }
public void TestMethodsWS() { using (var proxy = new GeneratedTest("http://localhost:3000/endpoint/1.0").UseWS()) { TestMethods(proxy); } }
private static void TestMethods() { using (var proxy = new GeneratedTest("http://localhost:3000/endpoint/1.0")) { try { Console.WriteLine(proxy/*.UseWS()*/.ThrowError().Result); } catch (Exception e) { Console.WriteLine(e.ToString()); } var task = proxy.Sum(1, 2); Console.WriteLine(task.Result); var r = new GeneratedTest.RenderOptions {width = 1, height = 2, renderMode = GeneratedTest.RenderMode.Production}; var taskEcho = proxy.Echo(r); Console.WriteLine(taskEcho.Result.ToString()); var o = new JObject(); o["a"] = JToken.FromObject(new[] { 1, 2 }); var taskEcho2 = proxy.EchoObject(o); Console.WriteLine(taskEcho2.Result.ToString()); // binary message var bytes = proxy.EchoStringAsBuffer("binary").Result; Console.WriteLine("bytes: {0}, message: {1}", bytes.Length, System.Text.Encoding.Default.GetString(bytes)); var bytesLength = proxy.GetBufferSize(bytes).Result; Console.WriteLine("bytes buffer size: {0}", bytesLength); } }
public void TestMethodsHTTP() { using (var proxy = new GeneratedTest("http://localhost:3000/endpoint/1.0").UseHTTP()) { TestMethods(proxy); } }
public static void UpdateTest(GeneratedTest newTest) { using (Entities e = new Entities()) { } //todo }
public AddUnitTestDialog(MonoDevelop.Ide.Gui.Document document, MethodDeclarationSyntax currentMethod, GeneratedTest generatedTestModel) { _testGeneratorService = CompositionManager.Instance.GetExportedValue <ITestGeneratorService>(); _currentMethod = currentMethod; _document = document; _generatedTestModel = generatedTestModel; WindowPosition = WindowPosition.CenterAlways; Title = "Add Unit test method"; //entry setup _unitTestNameTitle = new Label { Text = "Unit test name:" }; _unitTestName = new Entry(); _unitTestName.Activated += EntryActivated; //button setup _confirm = new Button { Label = "Create" }; _confirm.Clicked += Confirm_Clicked; VBox.Add(_unitTestNameTitle); VBox.Add(_unitTestName); VBox.Add(_confirm); VBox.ShowAll(); }
public void TestUnsubscribe() { var proxy = new GeneratedTest("http://localhost:3000/endpoint/1.0"); var n1 = 0; EventHandler<GeneratedTest.DataEventArgs<long>> testEventHandler = (sender, data) => { n1++; }; proxy.TestEvent += testEventHandler; Thread.Sleep(1500); proxy.TestEvent -= testEventHandler; Thread.Sleep(2000); Assert.AreEqual(n1, 1); }
public void TestUnsubscribe() { var proxy = new GeneratedTest("http://localhost:3000/endpoint/1.0"); var n1 = 0; EventHandler <GeneratedTest.DataEventArgs <long> > testEventHandler = (sender, data) => { n1++; }; proxy.TestEvent += testEventHandler; Thread.Sleep(1500); proxy.TestEvent -= testEventHandler; Thread.Sleep(2000); Assert.AreEqual(n1, 1); }
public async Task <ActionResult> Solve(int?id) { if (id == null) { return(View("Error")); } var test = await db.Tests.FindAsync(id); if (test == null) { return(View("Error")); } var u = db.Users.Find(User.Identity.GetUserId()); var generated = new GeneratedTest() { Date = DateTime.Now, Score = null, User = u, Test = test }; db.GeneratedTests.Add(generated); var questions = test.Questions.ToList(); questions.Shuffle(new Random()); var testquestions = new List <Question>(); for (int i = 0; i <= test.QuestionLimit - 1; i++) { if (i >= questions.Count) { break; } var questionanswer = new UserQuestionAnswer() { Question = questions[i] }; db.UserQuestionAnswers.Add(questionanswer); questionanswer.GeneratedTest = generated; testquestions.Add(questions[i]); } await db.SaveChangesAsync(); return(View(new TestSolveViewModel() { GeneratedId = generated.Id, Name = test.Name, CourseId = test.Course.Id, Questions = testquestions })); }
//create generated test public static WebResult AddGeneratedTest(GeneratedTest newtest) { using (Entities e = new Entities()) { WebResult wb = new WebResult(); try { //add new test test t = e.tests.Add(TestCasting.TestToDAL(newtest.test)); e.SaveChanges(); //add rand questions to the new test List <question> newQuesList = RandQues(t.test_id, t.level, newtest.american, newtest.yesNo, newtest.match, newtest.classes.FirstOrDefault().teacher_id, newtest.subCategories); t.classes.AddRange(ClassCasting.ClassesToDAL(newtest.classes)); newQuesList.ForEach(q => { question qq = new question() { question_level = q.question_level, question_id = q.question_id, question_text = q.question_text, //// answers = q.answers, // sub_category = q.sub_category, sub_category_id = q.sub_category_id, // tests = q.tests, // type = q.type, type_id = q.type_id }; t.questions.Add(qq); }); //t.questions.AddRange(newQuesList.ToList()); wb.status = true; wb.message = "succeed"; wb.value = TestCasting.TestToDTO(t); e.SaveChanges(); return(wb); } catch (Exception ex) { wb.status = false; wb.message = ex.Message; return(wb); } } }
private static void TestUnsubscribe() { var proxy = new GeneratedTest("http://localhost:3000/endpoint/1.0"); int n1 = 0; EventHandler <GeneratedTest.DataEventArgs <long> > testEventHandler = (sender, data) => { Console.WriteLine("event1:{0}", data.Data); n1++; }; proxy.TestEvent += testEventHandler; Thread.Sleep(5000); Console.WriteLine(n1); proxy.TestEvent -= testEventHandler; Thread.Sleep(5000); Console.WriteLine(n1); }
public IHttpActionResult AddGeneratedTest([FromBody] GeneratedTest newtest) { try { if (ModelState.IsValid) { return(Ok(TestLogic.AddGeneratedTest(newtest))); } var errors = ModelState.Select(x => x.Value.Errors) .Where(y => y.Count > 0) .ToList(); return(BadRequest(errors.ToString())); } catch (Exception ex) { return(BadRequest(ex.Message)); } }
public void TestEvents() { using (var proxy = new GeneratedTest("http://localhost:3000/endpoint/1.0")) { int n1 = 0; int n2 = 0; int n3 = 0; proxy.TestEvent2 += (sender, data) => { Console.WriteLine("event2:{0}", data.Data[0].width); n2++; }; proxy.TestEvent += (sender, data) => { Console.WriteLine("event1:{0}", data.Data); n1++; }; proxy.TestEvent3 += (sender, data) => { Console.WriteLine("event3:{0}", data.Data); n3++; }; string s = null; proxy.TestBinaryEvent += (sender, data) => { s = Encoding.UTF8.GetString(data.Data); Console.WriteLine(s); }; Thread.Sleep(6000); Assert.IsTrue(n1 > 0); Assert.IsTrue(n2 > 0); Assert.IsTrue(n3 > 0); Assert.AreEqual(s, "test binary event"); } }
private void TestMethods(GeneratedTest proxy) { try { Console.WriteLine(proxy.ThrowError().Result); Assert.Fail("Server-side exception was not rethrown on the client"); } catch (Exception) { } var task = proxy.Sum(1, 2); Assert.AreEqual(task.Result, 3); var r = new GeneratedTest.RenderOptions { width = 1, height = 2, renderMode = GeneratedTest.RenderMode.Production }; var taskEcho = proxy.Echo(r); Assert.AreEqual(r.width, taskEcho.Result.width); Assert.AreEqual(r.height, taskEcho.Result.height); Assert.AreEqual(r.renderMode, taskEcho.Result.renderMode); var o = new JObject(); o["a"] = JToken.FromObject(new[] { 1, 2 }); var taskEcho2 = proxy.EchoObject(o); Assert.AreEqual(o["a"].ToString(), taskEcho2.Result["a"].ToString()); var bytes = proxy.EchoStringAsBuffer("binary").Result; Assert.AreEqual("binary", Encoding.UTF8.GetString(bytes)); var bytesLength = proxy.GetBufferSize(bytes).Result; Assert.AreEqual(bytes.LongLength, bytesLength); }
public async Task <MonoDevelop.Ide.Gui.Document> OpenDocument(GeneratedTest generatedTestModel) { var config = await _configurationService.GetConfiguration(); var projects = IdeApp.Workspace.GetAllProjects(); var unitTestProject = projects.FirstOrDefault(p => p.Name == config.UnitTestProjectName); if (unitTestProject == null) { return(null); } var file = unitTestProject.Files.FirstOrDefault(f => f.FilePath == generatedTestModel.FilePath); if (file == null) { try { await _fileService.GenerateFile(generatedTestModel.Namespace, generatedTestModel.Name, generatedTestModel.FilePath); file = new ProjectFile(generatedTestModel.FilePath, BuildAction.Compile) { Visible = true, }; unitTestProject.AddFile(file); } catch (Exception e) { Debug.WriteLine(e); return(null); } } var document = await IdeApp.Workbench.OpenDocument(file.FilePath, unitTestProject, true); return(document); }
private static void TestMethods() { using (var proxy = new GeneratedTest("http://localhost:3000/endpoint/1.0")) { try { Console.WriteLine(proxy /*.UseWS()*/.ThrowError().Result); } catch (Exception e) { Console.WriteLine(e.ToString()); } var task = proxy.Sum(1, 2); Console.WriteLine(task.Result); var r = new GeneratedTest.RenderOptions { width = 1, height = 2, renderMode = GeneratedTest.RenderMode.Production }; var taskEcho = proxy.Echo(r); Console.WriteLine(taskEcho.Result.ToString()); var o = new JObject(); o["a"] = JToken.FromObject(new[] { 1, 2 }); var taskEcho2 = proxy.EchoObject(o); Console.WriteLine(taskEcho2.Result.ToString()); // binary message var bytes = proxy.EchoStringAsBuffer("binary").Result; Console.WriteLine("bytes: {0}, message: {1}", bytes.Length, System.Text.Encoding.Default.GetString(bytes)); var bytesLength = proxy.GetBufferSize(bytes).Result; Console.WriteLine("bytes buffer size: {0}", bytesLength); } }
private static void TestUnsubscribe() { var proxy = new GeneratedTest("http://localhost:3000/endpoint/1.0"); int n1 = 0; EventHandler<GeneratedTest.DataEventArgs<long>> testEventHandler = (sender, data) => { Console.WriteLine("event1:{0}", data.Data); n1++; }; proxy.TestEvent += testEventHandler; Thread.Sleep(5000); Console.WriteLine(n1); proxy.TestEvent -= testEventHandler; Thread.Sleep(5000); Console.WriteLine(n1); }
public MethodDeclarationSyntax GenerateUnitTestMethodDeclaration(string returnTypeName, SyntaxTokenList modifiers, string methodName, string testFramework, GeneratedTest generatedTestModel) { var annotation = "nunit".Equals(testFramework) ? "Test" : "Fact"; var bodyStatements = new List <StatementSyntax>(); var addedArrange = false; if (!string.IsNullOrWhiteSpace(generatedTestModel.ReturnType)) { bodyStatements.Add(SyntaxFactory.ParseStatement($"var expected = default({generatedTestModel.ReturnType});\n").WithLeadingTrivia(SyntaxFactory.Comment("//Arrange\n"))); addedArrange = true; } var methodParams = ""; if (generatedTestModel.MethodParameters != null && generatedTestModel.MethodParameters.Any()) { foreach (var parameter in generatedTestModel.MethodParameters) { if (!addedArrange) { bodyStatements.Add(SyntaxFactory.ParseStatement($"var {parameter.Name} = default({parameter.ClassName});\n").WithLeadingTrivia(SyntaxFactory.Comment("//Arrange\n"))); addedArrange = true; } else { bodyStatements.Add(SyntaxFactory.ParseStatement($"var {parameter.Name} = default({parameter.ClassName});\n")); } methodParams += $"{parameter.Name}, "; } } var ctorParams = ""; if (generatedTestModel.ClassConstructorParameters != null && generatedTestModel.ClassConstructorParameters.Any()) { foreach (var parameter in generatedTestModel.ClassConstructorParameters) { if (!addedArrange) { if (parameter.IsInterface) { bodyStatements.Add(SyntaxFactory.ParseStatement($"var {parameter.Name} = new Mock<{parameter.ClassName}>();\n").WithLeadingTrivia(SyntaxFactory.Comment("//Arrange\n"))); } else { bodyStatements.Add(SyntaxFactory.ParseStatement($"var {parameter.Name} = default({parameter.ClassName});\n").WithLeadingTrivia(SyntaxFactory.Comment("//Arrange\n"))); } addedArrange = true; } else { if (parameter.IsInterface) { bodyStatements.Add(SyntaxFactory.ParseStatement($"var {parameter.Name} = new Mock<{parameter.ClassName}>();\n")); } else { bodyStatements.Add(SyntaxFactory.ParseStatement($"var {parameter.Name} = default({parameter.ClassName});\n")); } } ctorParams += parameter.IsInterface ? $"{parameter.Name}.Object, " : $"{parameter.Name}, "; } } var classCtor = SyntaxFactory.ParseStatement($"var vm = new {generatedTestModel.ClassName}({ctorParams.TrimEnd(' ').TrimEnd(',')});\n").WithTrailingTrivia(SyntaxFactory.CarriageReturnLineFeed); bodyStatements.Add(classCtor); var resultSection = string.IsNullOrWhiteSpace(generatedTestModel.ReturnType) ? "" : "var result = "; var awaitSection = generatedTestModel.IsTask ? "await " : ""; bodyStatements.Add(SyntaxFactory.ParseStatement($"{resultSection}{awaitSection}vm.{generatedTestModel.MethodName}({methodParams.TrimEnd(' ').TrimEnd(',')});\n").WithLeadingTrivia(SyntaxFactory.Comment("//Act\n"))); //Generate the assert section if ("nunit".Equals(testFramework)) { if (!string.IsNullOrWhiteSpace(generatedTestModel.ReturnType)) { bodyStatements.Add(SyntaxFactory.ParseStatement("Assert.That(expected == result);\n").WithLeadingTrivia(SyntaxFactory.Comment("//Assert\n"))); } else { bodyStatements.Add(SyntaxFactory.ParseStatement("Assert.That(true);\n").WithLeadingTrivia(SyntaxFactory.Comment("//Assert\n"))); } } else { if (!string.IsNullOrWhiteSpace(generatedTestModel.ReturnType)) { bodyStatements.Add(SyntaxFactory.ParseStatement($"Assert.Equal<{generatedTestModel.ReturnType}>(expected, result);\n").WithLeadingTrivia(SyntaxFactory.Comment("//Assert\n"))); } else { bodyStatements.Add(SyntaxFactory.ParseStatement("Assert.True(true);\n").WithLeadingTrivia(SyntaxFactory.Comment("//Assert\n"))); } } var method = SyntaxFactory.MethodDeclaration(attributeLists: SyntaxFactory.List <AttributeListSyntax>(), modifiers: modifiers, returnType: SyntaxFactory.ParseTypeName(returnTypeName), explicitInterfaceSpecifier: null, identifier: SyntaxFactory.Identifier(methodName), typeParameterList: null, parameterList: SyntaxFactory.ParameterList(), constraintClauses: SyntaxFactory.List <TypeParameterConstraintClauseSyntax>(), body: SyntaxFactory.Block(bodyStatements), semicolonToken: SyntaxFactory.Token(SyntaxKind.None)) // Annotate that this node should be formatted .WithAdditionalAnnotations(Formatter.Annotation) .WithAttributeLists( SyntaxFactory.SingletonList( SyntaxFactory.AttributeList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Attribute( SyntaxFactory.IdentifierName(annotation)))))); return(method); }
public async Task <GeneratedTest> CreateGeneratedTestModel(MethodDeclarationSyntax method, Document analysisDocument) { //Get the configuration model var config = await _configurationService.GetConfiguration(); var generatedTest = new GeneratedTest(); generatedTest.RequiredNamespaces = new List <string>(); var projects = IdeApp.Workspace.GetAllProjects(); var unitTestProject = projects.FirstOrDefault(p => p.Name == config.UnitTestProjectName); if (unitTestProject == null) { return(null); } var classSyntax = method.Parent as ClassDeclarationSyntax; var namespaceSyntax = classSyntax.Parent as NamespaceDeclarationSyntax; var requiredFolders = namespaceSyntax.Name.ToString().Split('.').ToList(); if (requiredFolders == null || !requiredFolders.Any()) { return(null); } //remove the first part of namespace as per setting if (config.RemoveFirst) { requiredFolders.RemoveAt(0); } //add the class name of the method as another folder requiredFolders.Add(classSyntax.Identifier.Text + config.UnitTestClassSuffix); var outputFile = unitTestProject.BaseDirectory.ToString() + "/"; var namespaceId = config.UnitTestProjectName; foreach (var item in requiredFolders) { outputFile += item.Trim() + "/"; namespaceId += "." + item.Trim(); } outputFile += method.Identifier.Text + $"{config.UnitTestSuffix}.cs"; generatedTest.FilePath = outputFile; generatedTest.Namespace = namespaceId; generatedTest.Name = method.Identifier.Text + config.UnitTestSuffix; generatedTest.ClassName = classSyntax.Identifier.Text; generatedTest.MethodName = method.Identifier.Text; //Get the symantic model in order to resolve namespaces var editor = await DocumentEditor.CreateAsync(analysisDocument); var sematicModel = editor.SemanticModel; //class namespace generatedTest.RequiredNamespaces.Add(namespaceSyntax.Name.ToString()); //class constructor parameters var classConstructor = classSyntax.DescendantNodes().OfType <ConstructorDeclarationSyntax>().FirstOrDefault(); if (classConstructor != null && classConstructor.ParameterList != null && classConstructor.ParameterList.Parameters.Any()) { generatedTest.ClassConstructorParameters = new List <Parameter>(); foreach (var parameter in classConstructor.ParameterList.Parameters) { if (parameter.Type is IdentifierNameSyntax ins) { var isInterface = false; var typeInfo = sematicModel.GetTypeInfo(ins); if (typeInfo.Type is INamedTypeSymbol namedType) { if (namedType.TypeKind == TypeKind.Interface) { isInterface = true; } } generatedTest.ClassConstructorParameters.Add(new Parameter { Name = parameter.Identifier.Text, ClassName = ins.Identifier.Text, IsInterface = isInterface }); generatedTest.AddNamespaces(GetNamespacesForIdentifier(ins, sematicModel)); } else if (parameter.Type is PredefinedTypeSyntax pds) { generatedTest.ClassConstructorParameters.Add(new Parameter { Name = parameter.Identifier.Text, ClassName = pds.ToString() }); } else if (parameter.Type is GenericNameSyntax ns) { generatedTest.AddNamespaces(GetNamespacesForIdentifier(ns, sematicModel)); generatedTest.ClassConstructorParameters.Add(new Parameter { Name = parameter.Identifier.Text, ClassName = ns.Identifier.Text }); } } } //Method Parameters if (method.ParameterList.Parameters.Any()) { generatedTest.MethodParameters = new List <Parameter>(); foreach (var parameter in method.ParameterList.Parameters) { var className = ""; if (parameter.Type is IdentifierNameSyntax ins) { className = ins.Identifier.Text; generatedTest.AddNamespaces(GetNamespacesForIdentifier(ins, sematicModel)); } else if (parameter.Type is PredefinedTypeSyntax pds) { className = pds.ToString(); } else if (parameter.Type is GenericNameSyntax ns) { className = ns.ToString(); generatedTest.AddNamespaces(GetNamespacesForIdentifier(ns, sematicModel)); } generatedTest.MethodParameters.Add(new Parameter { Name = parameter.Identifier.Text, ClassName = className }); } } //Method return type calculation var isTask = false; if (method.ReturnType is GenericNameSyntax gns) { isTask |= gns.Identifier.Text.Equals("Task"); if (isTask) { generatedTest.ReturnType = gns.TypeArgumentList?.Arguments.FirstOrDefault()?.ToString(); } else { var rType = gns.Identifier.Text; var arguments = string.Join(",", gns.TypeArgumentList?.Arguments.Select(a => a.ToString())); if (!string.IsNullOrEmpty(arguments)) { rType += $"<{arguments}>"; } generatedTest.ReturnType = rType; } generatedTest.AddNamespaces(GetNamespacesForIdentifier(method.ReturnType, sematicModel)); } else if (method.ReturnType is IdentifierNameSyntax ins) { isTask |= ins.Identifier.Text.Equals("Task"); generatedTest.ReturnType = ins.ToString().Equals("Task") ? null : ins.ToString(); generatedTest.AddNamespaces(GetNamespacesForIdentifier(method.ReturnType, sematicModel)); } else if (method.ReturnType is PredefinedTypeSyntax pns) { generatedTest.ReturnType = pns.ToString().Equals("void") ? null : pns.ToString(); } generatedTest.IsTask = isTask; return(generatedTest); }
public async Task GenerateUnitTest(string unitTestName, MethodDeclarationSyntax currentMethod, MonoDevelop.Ide.Gui.Document document, GeneratedTest generatedTestModel) { var returnType = generatedTestModel.IsTask ? "Task" : "void"; var modifiers = SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword)); if (generatedTestModel.IsTask) { modifiers = SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.AsyncKeyword)); } var config = await _configurationService.GetConfiguration(); var annotation = "Test"; if ("xunit".Equals(config.TestFramework)) { annotation = "Fact"; } var newMethod = GenerateUnitTestMethodDeclaration(returnType, modifiers, unitTestName, annotation, generatedTestModel); var analysisDoc = document.GetAnalysisDocument(); var editor = await DocumentEditor.CreateAsync(analysisDoc); var cuRoot = editor.SemanticModel.SyntaxTree.GetCompilationUnitRoot(); if (cuRoot == null) { return; } //add required using statements that havent already been added if (generatedTestModel.RequiredNamespaces != null && generatedTestModel.RequiredNamespaces.Any()) { var usingNames = cuRoot.Usings.Select(u => u.Name.ToString()); var requiredUsings = new List <UsingDirectiveSyntax>(); foreach (var usingStatement in generatedTestModel.RequiredNamespaces) { if (!usingNames.Contains(usingStatement)) { requiredUsings.Add(GenerateUsingSyntax(usingStatement)); } } if (requiredUsings.Any()) { var updatedRoot = cuRoot.AddUsings(requiredUsings.ToArray()); editor.ReplaceNode(cuRoot, updatedRoot); cuRoot = updatedRoot; } } var lastMethod = cuRoot.DescendantNodes().OfType <MethodDeclarationSyntax>().LastOrDefault(); if (lastMethod != null) { editor.InsertAfter(lastMethod, newMethod); } else { var classDeclaration = cuRoot.DescendantNodes().OfType <ClassDeclarationSyntax>().First(); var newClassDeclaration = classDeclaration.AddMembers(newMethod); editor.ReplaceNode(classDeclaration, newClassDeclaration); } var newDocument = editor.GetChangedDocument(); var newRoot = await newDocument.GetSyntaxRootAsync(); var textBuffer = document.GetContent <ITextBuffer>(); Microsoft.CodeAnalysis.Workspace.TryGetWorkspace(textBuffer.AsTextContainer(), out var workspace); newRoot = Formatter.Format(newRoot, Formatter.Annotation, workspace); workspace.TryApplyChanges(newDocument.WithSyntaxRoot(newRoot).Project.Solution); await document.Save(); }