using System;

using System.Collections.Generic;

using System.Text.RegularExpressions;

public class Program

{

    public static void Main()

    {

        var checks = new Dictionary<Regex,bool> {

            { new Regex("abc",RegexOptions.IgnoreCase), true },

            { new Regex("ABC",RegexOptions.IgnoreCase), true },

            { new Regex("[ABC]"), false },

            { new Regex("[abc]"), true },

            { new Regex("[abc^ABC]"), true },

            { new Regex("[ABC^abc]"), false },

            { new Regex(@"\[abc^ABC\]"), true },

            { new Regex(@"\[ABC^abc\]"), true },

            { new Regex("[aBC^Abc]"), true },

            { new Regex("[Abc^aBC]"), true },

            { new Regex(@"\p{Ll}"), true },

            { new Regex(@"\\p{Ll}"), true },

            { new Regex(@"\P{Ll}"), false },

            { new Regex(@"\p{Lu}"), false },

            { new Regex(@"\\p{Lu}"), true },

            { new Regex(@"\P{Lu}"), true },

        };

        Console.WriteLine("CheckIfRegexAcceptsLowercase:");

        foreach ( var check in checks ) {

            var c = check.Value;

            var t = CheckIfRegexAcceptsLowercase(check.Key);

            Console.WriteLine( " {0} {1} => {2} {3} {4}", check.Key.ToString(), check.Key.Options, c, c == t ? "==" : "!=" , t );

        }

        var checks2 = new Dictionary<Regex,bool> {

            { new Regex("abc",RegexOptions.IgnoreCase), true },

            { new Regex("ABC",RegexOptions.IgnoreCase), true },

            { new Regex("[ABC]"), true },

            { new Regex("[abc]"), false },

            { new Regex("[abc^ABC]"), false },

            { new Regex("[ABC^abc]"), true },

            { new Regex(@"\[abc^ABC\]"), true },

            { new Regex(@"\[ABC^abc\]"), true },

            { new Regex("[aBC^Abc]"), true },

            { new Regex("[Abc^aBC]"), true },

            { new Regex(@"\p{Ll}"), false },

            { new Regex(@"\\p{Ll}"), true },

            { new Regex(@"\P{Ll}"), true },

            { new Regex(@"\p{Lu}"), true },

            { new Regex(@"\\p{Lu}"), true },

            { new Regex(@"\P{Lu}"), false },

        };

        Console.WriteLine();

        Console.WriteLine("CheckIfRegexAcceptsUppercase:");

        foreach ( var check in checks2 ) {

            var c = check.Value;

            var t = CheckIfRegexAcceptsUppercase(check.Key);

            Console.WriteLine( " {0} {1} => {2} {3} {4}", check.Key.ToString(), check.Key.Options, c, c == t ? "==" : "!=" , t );

        }

    }

    public static readonly Regex rxCheckIfRegexAcceptsLowercase = new Regex(

        @"

        (?:

         (?<!(?<!\\)\[[^\]]*)|

         (?<!(?<!\\)\[[^\]]*\^[^\]]*)

        )

        (?:

         (?<!\\)\\p\{Ll\}|

         (?<!\\)\\P\{Lu\}|

         (?<!(?<!\\)\\[pP]\{L(?=[lu]))(?<!\\)\p{Ll}|

         (?<!\\)\\w

        )

        ",

        RegexOptions.CultureInvariant|RegexOptions.IgnorePatternWhitespace);

    public static readonly Regex rxCheckIfRegexAcceptsUppercase = new Regex(

        @"

        (?:

         (?<!(?<!\\)\[[^\]]*)|

         (?<!(?<!\\)\[[^\]]*\^[^\]]*)

        )

        (?:

         (?<!\\)\\p\{Lu\}|

         (?<!\\)\\P\{Ll\}|

         (?<!(?<!\\)\\[pP]\{(?=[L]))(?<!\\)\p{Lu}|

         (?<!\\)\\w

        )

        ",

        RegexOptions.CultureInvariant|RegexOptions.IgnorePatternWhitespace);

    public static bool CheckIfRegexAcceptsLowercase(Regex rx) {

        if ( (rx.Options & RegexOptions.IgnoreCase) == RegexOptions.IgnoreCase )

            return true;

        if ( rxCheckIfRegexAcceptsLowercase.IsMatch(rx.ToString()) )

            return true;

        return false;

    }

    public static bool CheckIfRegexAcceptsUppercase(Regex rx) {

        if ( (rx.Options & RegexOptions.IgnoreCase) == RegexOptions.IgnoreCase )

            return true;

        if ( rxCheckIfRegexAcceptsUppercase.IsMatch(rx.ToString()) )

            return true;

        return false;

    }

}