public static IEnumerable<string> GetHelp(ScriptSession session, string command)
 {
     Collection<PSParseError> errors;
     var tokens = PSParser.Tokenize(command, out errors);
     var lastPsToken = tokens.LastOrDefault(t => t.Type == PSTokenType.Command);
     if (lastPsToken != null)
     {
         session.Output.Clear();
         var lastToken = lastPsToken.Content;
         session.SetVariable("helpFor", lastToken);
         var platformmodule = ModuleManager.GetModule("Platform");
         var scriptItem = Database.GetDatabase(platformmodule.Database)
             .GetItem(platformmodule.Path + "/Internal/Context Help/Command Help");
         if (scriptItem == null)
         {
             scriptItem = Factory.GetDatabase(ApplicationSettings.ScriptLibraryDb)
                 .GetItem(ApplicationSettings.ScriptLibraryPath + "Internal/Context Help/Command Help");
         }
         session.ExecuteScriptPart(scriptItem[ScriptItemFieldNames.Script], true, true);
         var sb = new StringBuilder("<div id=\"HelpClose\">X</div>");
         if (session.Output.Count == 0 || session.Output[0].LineType == OutputLineType.Error)
         {
             return new[]
             {
                 "<div class='ps-help-command-name'>&nbsp;</div><div class='ps-help-header' align='center'>No Command in line or help information found</div><div class='ps-help-parameter' align='center'>Cannot provide help in this context.</div>"
             };
         }
         session.Output.ForEach(l => sb.Append(l.Text));
         session.Output.Clear();
         var result = new[] {sb.ToString()};
         return result;
     }
     return new[] {"No Command in line found - cannot provide help in this context."};
 }

        public ActionResult Index()
        {
            var themes = new List<dynamic>();
            var dirbase = new DirectoryInfo(HttpContext.Server.MapPath(string.Format("~/Content/js/easyui/{0}/themes", AppSettings.EasyuiVersion)));
            DirectoryInfo[] dirs = dirbase.GetDirectories();
            foreach (var dir in dirs)
                if (dir.Name != "icons")
                    themes.Add(new {text=dir.Name,value=dir.Name });

            var navigations = new List<dynamic>();
            navigations.Add(new { text = "手风琴-2级(默认)", value = "accordion" });
            //navigations.Add(new { text = "手风琴大图标-2级", value = "accordionbigicon" });
            navigations.Add(new { text = "手风琴树", value = "accordiontree" });
            navigations.Add(new { text = "横向菜单", value = "menubutton" });
            navigations.Add(new { text = "树形结构", value = "tree" });
 
            var model = new {
                dataSource = new{
                    themes=themes,
                    navigations=navigations
                },
                form=  new sys_userService().GetCurrentUserSettings()             
            };

            return View(model);
        }

        public ActionResult Search(string query)
        {
            ViewData["Message"] = "query : " + query;

            var searcher = new IndexSearcher(
                new Lucene.Net.Store.SimpleFSDirectory(new DirectoryInfo(Configuration.IndexDirectory)),
                readOnly: true);

            var fieldsToSearchIn = new[] {Configuration.Fields.Name, Configuration.Fields.Description};
            var queryanalizer = new MultiFieldQueryParser(Version.LUCENE_CURRENT,
                                                          fieldsToSearchIn,
                                                          new BrazilianAnalyzer());

            var numberOfResults = 10;
            var top10Results = searcher.Search(queryanalizer.Parse(query), numberOfResults);
            var docs = new List<DocumentViewModel>();
            foreach (var scoreDoc in top10Results.scoreDocs)
            {
                var document = searcher.Doc(scoreDoc.doc);
                var name = document.GetField(Configuration.Fields.Name).StringValue();
                var description = document.GetField(Configuration.Fields.Description).StringValue();
                var link = document.GetField(Configuration.Fields.Link).StringValue();
                docs.Add(new DocumentViewModel(name, description, link));
            }
            return View(new SearchViewModel(docs));
        }

        internal static async Task TestNotReusedOnAssemblyDiffersAsync(string projectLanguage)
        {
            var metadataSources = new[]
            {
                @"[assembly: System.Reflection.AssemblyVersion(""1.0.0.0"")] public class D {}",
                @"[assembly: System.Reflection.AssemblyVersion(""2.0.0.0"")] public class D {}"
            };

            using (var context = await TestContext.CreateAsync(projectLanguage))
            {
                var projectId = ProjectId.CreateNewId();
                var metadataProject = context.CurrentSolution
                    .AddProject(projectId, "Metadata", "Metadata", LanguageNames.CSharp).GetProject(projectId)
                    .AddMetadataReference(TestReferences.NetFx.v4_0_30319.mscorlib)
                    .WithCompilationOptions(new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary, optimizationLevel: OptimizationLevel.Release));

                var references = new List<MetadataReference>();

                foreach (var source in metadataSources)
                {
                    var newDoc = metadataProject.AddDocument("MetadataSource", source);
                    metadataProject = newDoc.Project;
                    references.Add(MetadataReference.CreateFromImage((await metadataProject.GetCompilationAsync()).EmitToArray()));
                    metadataProject = metadataProject.RemoveDocument(newDoc.Id);
                }

                var project = context.DefaultProject.AddMetadataReference(references[0]);
                var a = await context.GenerateSourceAsync("D", project);

                project = project.RemoveMetadataReference(references[0]).AddMetadataReference(references[1]);
                var b = await context.GenerateSourceAsync("D", project);

                context.VerifyDocumentNotReused(a, b);
            }
        }

        public void MapToTokenModelTest()
        {
            const string email = "[email protected]";
            const int id = 1;
            const string hash = "HashToken";
            IEnumerable<string> roles = new[] {"Admin", "Student", "Teacher"};
            Mock<ITokenValidation> token = new Mock<ITokenValidation>();
            UserToTokenMapper mapper = new UserToTokenMapper(token.Object);

            var initial = new UserWithPasswordModel()
            {
                Email = email,
                Id = id,
                HashToken = hash,
                Roles = roles
            };
            var expected = new TokenModel()
            {
                EmailAndIdToken = email,
                RolesToken = roles.ToString(),
                HashToken = hash
            };

            token.Setup(x => x.EncodeEmailAndIdToken(id.ToString() + ' ' + email.ToLower()))
                .Returns(email);

            token.Setup(x => x.EncodeRoleToken(roles))
                .Returns(roles.ToString);

            var action = mapper.MapToTokenModel(initial);
            Assert.IsNotNull(action);
            Assert.AreEqual(action.EmailAndIdToken, expected.EmailAndIdToken);
            Assert.AreEqual(action.HashToken, expected.HashToken);
            Assert.AreEqual(action.RolesToken, expected.RolesToken);
        }

        public async Task TestLowerCaseComlicatedNamespaceAsync()
        {
            var testCode = @"namespace test.foo.bar
{

}";

            var fixedCode = @"namespace Test.Foo.Bar
{

}";

            DiagnosticResult[] expected = new[]
            {
                this.CSharpDiagnostic().WithArguments("test").WithLocation(1, 11),
                this.CSharpDiagnostic().WithArguments("test").WithLocation(1, 11),
                this.CSharpDiagnostic().WithArguments("test").WithLocation(1, 11),
                this.CSharpDiagnostic().WithArguments("foo").WithLocation(1, 16),
                this.CSharpDiagnostic().WithArguments("foo").WithLocation(1, 16),
                this.CSharpDiagnostic().WithArguments("foo").WithLocation(1, 16),
                this.CSharpDiagnostic().WithArguments("bar").WithLocation(1, 20),
                this.CSharpDiagnostic().WithArguments("bar").WithLocation(1, 20),
                this.CSharpDiagnostic().WithArguments("bar").WithLocation(1, 20)
            };

            await this.VerifyCSharpDiagnosticAsync(testCode, expected, CancellationToken.None).ConfigureAwait(false);
            await this.VerifyCSharpDiagnosticAsync(fixedCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
            await this.VerifyCSharpFixAsync(testCode, fixedCode).ConfigureAwait(false);
        }

        private void WriteNodes(XElement nodes)
        {
            foreach (NodeInfo nodeInfo in _snapshot.Nodes)
            {
                var labelComponents = new[] {nodeInfo.NodeType.ToString(), nodeInfo.Details}
                    .Union(nodeInfo.Conditions)
                    .Union(nodeInfo.Expressions)
                    .Where(x => !string.IsNullOrEmpty(x));
                string label = string.Join("\n", labelComponents);
                var node = new XElement(Name("Node"),
                                        new XAttribute("Id", Id(nodeInfo)),
                                        new XAttribute("Category", nodeInfo.NodeType),
                                        new XAttribute("Label", label));
                if (nodeInfo.Items.Length > 0)
                {
                    node.Add(new XAttribute("Group", "Collapsed"));
                }
                nodes.Add(node);

                for (int i = 0; i < nodeInfo.Items.Length; i++)
                {
                    var itemNode = new XElement(Name("Node"),
                        new XAttribute("Id", SubNodeId(nodeInfo, i)),
                        new XAttribute("Label", nodeInfo.Items[i]),
                        new XAttribute("Style", "Plain"));
                    nodes.Add(itemNode);
                }
            }
        }

        public ActionResult GetLogGridItems(GridSettings gridSettings)
        {
            var logGridItems = _logRepository.GetLogItems(gridSettings);
            var totalLogGridItems = _logRepository.CountLogItems(gridSettings);
            var pageIndex = gridSettings.PageIndex;
            var pageSize = gridSettings.PageSize;

            var jsonData = new
            {
                total = (totalLogGridItems / pageSize) + ((totalLogGridItems % pageSize > 0) ? 1 : 0),
                page = pageIndex,
                records = totalLogGridItems,
                rows = (from logItem in logGridItems
                        select new Dictionary<string, string>
                                            {
                                                { "Id", logItem.Id.ToString() },
                                                { "Created", logItem.Created.ToString() },
                                                { "Level", logItem.Level },
                                                { "Username", logItem.Username },
                                                { "Message", logItem.Message}
                                }).ToArray()
            };

            return Json(jsonData, JsonRequestBehavior.AllowGet);
        }

        public void SortListOfInts()
        {
            var unsorted = new[] { 5, 2, 3, -1, 8 };
            var sorted = new[] { -1, 2, 3, 5, 8 };

            Assert.That(InsertionSortIEnumerable(unsorted), Is.EqualTo(sorted));
        }

 private static void AssertInequalities(string[] subject)
 {
     var reference = new[] { "foo", "bar", "baz" };
     IComparer<IEnumerable<string>> comparer = new EnumerableComparer<string>();
     Assert.AreEqual(-1, comparer.Compare(reference, subject));
     Assert.AreEqual(1, comparer.Compare(subject, reference));
 }

        public void FiltersForLineItemType()
        {
            // Arrange
            var sw = new StringWriter();
            using (var csv = new CsvWriter(sw))
            {
                var lineItems = new[]
                {
                    new LineItem {RecordType = "Dummy"},
                    new LineItem {RecordType = "LineItem", RecordId = "Hoojey"}
                };
                csv.WriteHeader<LineItem>();
                csv.WriteRecords(lineItems);
            }

            // Act
            List<LineItem> parsedItems;
            using (var reader = new StringReader(sw.ToString()))
            {
                using (var parser = new LineItemCsvParser(reader))
                {
                    parsedItems = parser.GetLineItems().ToList();
                }
            }

            // Assert
            parsedItems.Count.Should().Be(1);
            parsedItems[0].RecordId.Should().Be("Hoojey");
        }

        public void ByViewAndVectorAnalysisData_ValidArgs()
        {
            var samplePoints = new[]
            {
                Point.ByCoordinates(0, 2, 4),
                Point.ByCoordinates(0, 7, 4),
                Point.ByCoordinates(0, 19, 4)
            };

            var sampleValues = new[]
            {
                Vector.ByCoordinates(0, 2, 4),
                Vector.ByCoordinates(0, 7, 4),
                Vector.ByCoordinates(0, 19, 4)
            };

            var data = VectorAnalysisData.ByPointsAndResults(
                samplePoints,
                new List<string>() { "Test vector data." },
                new List<IList<Vector>>() { sampleValues });

            var doc = Document.Current;
            var grid = VectorAnalysisDisplay.ByViewAndVectorAnalysisData(doc.ActiveView, new []{data});

            Assert.NotNull(grid);
        }

        private static string[] GetLibrariesScript()
        {
            string[] libraries = new[]
            {
                "~/Scripts/jquery-1.9.1.js",
                "~/Scripts/jquery.address.js",
                "~/Scripts/jquery-ui.js",
                "~/Scripts/jquery-timePicker/jquery.timepicker.js",
                "~/Scripts/shortcut.js",
                "~/Scripts/colorbox/jquery.colorbox.js",
                "~/Scripts/jqueryNumber/jquery.number.js",
                "~/Scripts/date.js",
                "~/Scripts/chartjs/Chart.min.js",
                "~/Scripts/chartjs/legend.js",
                "~/Scripts/notify-combined.min.js",
                "~/Scripts/semantic-ui/semantic.js",
                "~/Scripts/jquery.signalR.js",
                "~/Scripts/vakata-jstree/dist/jstree.min.js",
                "~/Scripts/momentjs/moment-with-locales.js",
                "~/Scripts/underscore/underscore-min.js",
                "~/Scripts/angular/angular.min.js",
                "~/Scripts/linq.js/linq.js"
            };

            libraries = libraries.Concat(GetMixERPCoreScript()).ToArray();

            return libraries;
        }

        public async Task TestCtor()
        {
            var blocks = new[] {
                new TransformBlock<int, string>(i => i.ToString()),
                new TransformBlock<int, string>(i => i.ToString(), new ExecutionDataflowBlockOptions { MaxMessagesPerTask = 1 }),
                new TransformBlock<int, string>(i => Task.Run(() => i.ToString()), new ExecutionDataflowBlockOptions { MaxMessagesPerTask = 1 })
            };
            foreach (var block in blocks)
            {
                Assert.Equal(expected: 0, actual: block.InputCount);
                Assert.Equal(expected: 0, actual: block.OutputCount);
                Assert.False(block.Completion.IsCompleted);
            }

            blocks = new[] {
                new TransformBlock<int, string>(i => i.ToString(), 
                    new ExecutionDataflowBlockOptions { CancellationToken = new CancellationToken(true) }),
                new TransformBlock<int, string>(i => Task.Run(() => i.ToString()), 
                    new ExecutionDataflowBlockOptions { CancellationToken = new CancellationToken(true) })
            };
            foreach (var block in blocks)
            {
                Assert.Equal(expected: 0, actual: block.InputCount);
                Assert.Equal(expected: 0, actual: block.OutputCount);
                await Assert.ThrowsAnyAsync<OperationCanceledException>(() => block.Completion);
            }
        }

 public override IEnumerable<OperatorElement> FindPath(Element target)
 {
     var pathHere = new[] {this};
     if (ReferenceEquals(Elements.Lhs, target) || ReferenceEquals(Elements.Rhs, target)) return pathHere;
     var pathFromHere = Elements.Lhs.FindPath(target) ?? Elements.Rhs.FindPath(target);
     return pathFromHere != null ? pathHere.Concat(pathFromHere) : null;
 }

 public void HashCodeBasedOnEquality()
 {
     string[] names = new[] {"foo", "bar", "baz", "quux", "quuux"};
     for (int i = 0; i <= names.Length; ++i)
     {
         for (int j = 0; j != 3; ++j)
         {
             for (int x = 0; x <= names.Length; ++x)
             {
                 for (int y = 0; y != 3; ++y)
                 {
                     var info0 = new CallInfo(i + j, names.Take(i));
                     var info1 = new CallInfo(x + y, names.Take(x));
                     if (info0.Equals(info1))
                     {
                         Assert.Equal(info0.GetHashCode(), info1.GetHashCode());
                     }
                     else
                     {
                         // Failure at this point is not definitely a bug,
                         // but should be considered a concern unless it can be
                         // convincingly ruled a fluke.
                         Assert.NotEqual(info0.GetHashCode(), info1.GetHashCode());
                     }
                 }
             }
         }
     }
 }

        public void ParseCommandLineArguments_ShouldUseBaseParserToParseArgs()
        {
            var args = new[] { "foo", "bar" };
            parser.ParseCommandLineArguments(args);

            baseParser.Received().ParseCommandLineArguments(args);
        }

        public void SearchUsesServiceMethodIfServerSupportsIt()
        {
            // Arrange
            var client = new Mock<IHttpClient>();
            var context = new Mock<IDataServiceContext>();
            var repository = new Mock<DataServicePackageRepository>(client.Object) { CallBase = true };
            var packages = new[] { 
                PackageUtility.CreatePackage("A", description:"New and aweseome"),
                PackageUtility.CreatePackage("B", description:"old and bad"),
                PackageUtility.CreatePackage("C", description:"rich")
            };
            repository.Setup(m => m.GetPackages()).Returns(packages.AsQueryable());
            repository.Object.Context = context.Object;
            context.Setup(m => m.SupportsServiceMethod("Search")).Returns(true);
            context.Setup(m => m.CreateQuery<DataServicePackage>(It.IsAny<string>(), It.IsAny<IDictionary<string, object>>()))
                   .Callback<string, IDictionary<string, object>>((entitySet, parameters) =>
                   {
                       // Assert
                       Assert.Equal("Search", entitySet);
                       Assert.Equal(2, parameters.Count);
                       Assert.Equal("'old'", parameters["searchTerm"]);
                       Assert.Equal("''", parameters["targetFramework"]);
                   })
                   .Returns(new Mock<IDataServiceQuery<DataServicePackage>>().Object);

            // Act
            repository.Object.Search("old", allowPrereleaseVersions: false);
        }

        public void CombineWith()
        {
            // Arrange
            List<string> log = new List<string>();

            ModelValidationNode[] allChildNodes = new[]
            {
                new ModelValidationNode(GetModelMetadata(), "key1"),
                new ModelValidationNode(GetModelMetadata(), "key2"),
                new ModelValidationNode(GetModelMetadata(), "key3"),
            };

            ModelValidationNode parentNode1 = new ModelValidationNode(GetModelMetadata(), "parent1");
            parentNode1.ChildNodes.Add(allChildNodes[0]);
            parentNode1.Validating += (sender, e) => log.Add("Validating parent1.");
            parentNode1.Validated += (sender, e) => log.Add("Validated parent1.");

            ModelValidationNode parentNode2 = new ModelValidationNode(GetModelMetadata(), "parent2");
            parentNode2.ChildNodes.Add(allChildNodes[1]);
            parentNode2.ChildNodes.Add(allChildNodes[2]);
            parentNode2.Validating += (sender, e) => log.Add("Validating parent2.");
            parentNode2.Validated += (sender, e) => log.Add("Validated parent2.");

            // Act
            parentNode1.CombineWith(parentNode2);
            parentNode1.Validate(ContextUtil.CreateActionContext());

            // Assert
            Assert.Equal(new[] { "Validating parent1.", "Validating parent2.", "Validated parent1.", "Validated parent2." }, log.ToArray());
            Assert.Equal(allChildNodes, parentNode1.ChildNodes.ToArray());
        }

 public async Task GetUserClaimTest()
 {
     var db = UnitTestHelper.CreateDefaultDb();
     var manager = new UserManager<IdentityUser>(new UserStore<IdentityUser>(db));
     var user = new IdentityUser("u1");
     var result = await manager.CreateAsync(user);
     UnitTestHelper.IsSuccess(result);
     Assert.NotNull(user);
     var claims = new[]
     {
         new Claim("c1", "v1"),
         new Claim("c2", "v2"),
         new Claim("c3", "v3")
     };
     foreach (Claim c in claims)
     {
         UnitTestHelper.IsSuccess(await manager.AddClaimAsync(user.Id, c));
     }
     var userClaims = new List<Claim>(await manager.GetClaimsAsync(user.Id));
     Assert.Equal(3, userClaims.Count);
     foreach (Claim c in claims)
     {
         Assert.True(userClaims.Exists(u => u.Type == c.Type && u.Value == c.Value));
     }
 }