public void Should_tokenize_properly_with_case_sensitivity_configured(KeywordBase keyword)
        {
            var syntax = HandyQueryLanguage.BuildSyntax().WithCaseSensitiveKeywords();
            var config = HandyQueryLanguage.Configure <Person>(syntax).Build();
            var text   = config.Syntax.KeywordsMap[keyword];

            if (text.All(x => !char.IsLetterOrDigit(x)))
            {
                // special characters could be case invariant
                return;
            }

            // original case - should be able to tokenize
            {
                GivenQuery($"Name |{text}| and");
                GivenConfig(config);
                WhenTokenized();
                ThenSuccess(keyword);
            }

            // upper cased - should not be able to tokenize
            {
                var upperCased = config.Syntax.KeywordsMap[keyword].ToUpper();
                GivenQuery($"Name |{upperCased} and");
                GivenConfig(config);
                WhenTokenized();
                ThenFailed();
            }
        }
        public void NumberLiteralToken_TryEvaluate <T>(string number, T expectedResult, bool expectedEvaluated)
            where T : struct
        {
            var token        = new NumberLiteralToken(0, number.Length);
            var syntaxConfig = HandyQueryLanguage.BuildSyntax().Build();

            var evaluated = token.TryEvaluate <T>(number, syntaxConfig, out var result);

            result.Should().Be(expectedResult);
            evaluated.Should().Be(expectedEvaluated);
        }
        public void Should_be_able_to_build_basic_configuration()
        {
            var syntax = HandyQueryLanguage.BuildSyntax()
                         .WithCaseSensitiveKeywords()
                         .WithCaseSensitiveColumnNames();

            var configurationBuilder = HandyQueryLanguage.Configure <Person>(syntax)
                                       .AddColumn(x => x.FirstName)
                                       .AddColumn(x => x.LastName)
                                       .AddColumn("MiddleName", x => x.LastName);

            var configuration = configurationBuilder.Build();

            configuration.Should().BeEquivalentTo(new LanguageConfig(typeof(Person), new List <ColumnInfo>()
            {
                new ColumnInfo("FirstName", "FirstName", typeof(string)),
                new ColumnInfo("LastName", "LastName", typeof(string)),
                new ColumnInfo("MiddleName", "LastName", typeof(string))
            }, new SyntaxConfig(true, true)));
        }
 private static IEnumerable <TestCaseData> GetAllKeywordsWithWhiteSpaces()
 {
     return(HandyQueryLanguage.BuildSyntax().Build().KeywordsMap
            .Where(x => x.Value.Contains(" "))
            .Select(x => new TestCaseData(x.Key, x.Value)));
 }
 private static IEnumerable <KeywordBase> GetAllKeywords()
 => HandyQueryLanguage.BuildSyntax().Build().KeywordsMap.Keys;