/// <summary>
 /// Checks a single IP.
 /// </summary>
 /// <param name="ip">IP to check.</param>
 /// <param name="type">Check type.</param>
 /// <returns>Returns true if IP could be found in the list and false if it couldn't be found.</returns>
 public override bool CheckSingleIP(string ip, CheckType type)
 {
     if (type == CheckType.Trusted)
         return IsTrusted(ip, ValidationType.Single);
     else
         return IsBlocked(ip, ValidationType.Single);
 }

 public CustomSecurityCheckAttribute(CheckType type)
 {
     CheckList.Add(new CheckItem
     {
         Type = type
     });
 }

        /// -------------------------------------------------------------------
        /// <summary></summary>
        /// -------------------------------------------------------------------
        internal void pattern_SetValue(object val, Type expectedException, CheckType checkType)
        {
            string newVal = Convert.ToString(val, CultureInfo.CurrentUICulture);

            string call = "SetValue(" + newVal + ")";

            try
            {
                Comment("Before " + call + " Value = " + pattern_Value);
                _pattern.SetValue(newVal);
                Comment("After " + call + " Value = " + pattern_Value);

                // Are we in a "no-clobber" state?  If so, bail gracefully
                // This is why we throw an IncorrectElementConfiguration instead of
                // default value of checkType
                if (_noClobber == true)
                {
                    ThrowMe(CheckType.IncorrectElementConfiguration, "/NOCLOBBER flag is set, cannot update the value of the control, exiting gracefully");
                }
            }

            catch (Exception actualException)
            {
                if (Library.IsCriticalException(actualException))
                    throw;

                TestException(expectedException, actualException, call, checkType);
                return;
            }
            TestNoException(expectedException, call, checkType);
        }

        public NPCChecks(CheckType check, params object[] p)
        {
            Type = check;

            for (int i = 0; i < p.Length; i++)
                Params.Add(p[i]);
        }

        /// <summary>
        /// Creates a new <c>RingCheck</c> that relates to the specified polygon ring.
        /// </summary>
        /// <param name="ring">The polygon ring the check relates to (not null).</param>
        /// <param name="types">The type(s) of check this item corresponds to</param>
        /// <exception cref="ArgumentNullException">If <paramref name="ring"/> is null</exception>
        internal RingCheck(Ring ring, CheckType types)
            : base(types)
        {
            if (ring==null)
                throw new ArgumentNullException();

            m_Ring = ring;
        }

        /// <summary>
        /// Creates a new <c>TextCheck</c> that relates to the specified text.
        /// </summary>
        /// <param name="label">The text the check relates to (not null).</param>
        /// <param name="types">The type(s) of check this item corresponds to</param>
        /// <exception cref="ArgumentNullException">If <paramref name="label"/> is null</exception>
        internal TextCheck(TextFeature label, CheckType types)
            : base(types)
        {
            if (label==null)
                throw new ArgumentNullException();

            m_Label = label;
        }

        public void EnumHelper_Parse_ReturnsCorrectEnum(string value, CheckType checkType)
        {
            //act
            var result = EnumHelper<CheckType>.Parse(value);

            //assert
            result.Should().Be(checkType);
        }

        /// <summary>
        /// Creates a new <c>DividerCheck</c> that relates to the specified divider.
        /// </summary>
        /// <param name="divider">The divider the check relates to (not null).</param>
        /// <param name="types">The type(s) of check this item corresponds to</param>
        /// <exception cref="ArgumentNullException">If <paramref name="divider"/> is null</exception>
        internal DividerCheck(IDivider divider, CheckType types)
            : base(types)
        {
            if (divider==null)
                throw new ArgumentNullException();

            m_Divider = divider;
        }

        public void ParseCheckType_ReturnsCorrectString(CheckType checkType, string expected)
        {
            //act
            var result = EnumFactory.ParseCheckType(checkType);

            //assert
            result.Should().Be(expected);
        }

 public FieldNameCheck(string FieldName, CheckType[] Types, string[] ErrMsgs, OutputError Output, object[] Other)
 {
     this.FieldName = FieldName;
     this.Types = Types;
     this.ErrMsgs = ErrMsgs;
     this.Params = Other;
     this.Output = Output;
 }

 public static bool IsRepeate(CheckType t,string value)
 {
     switch(t){
         case CheckType.TagName:
             return IsTagNameRepeate(value);
         default:
             return false;
     }                
 }

        /// -------------------------------------------------------------------
        /// <summary></summary>
        /// -------------------------------------------------------------------
        internal SelectionItemPattern getSelectionItemPattern(AutomationElement element, CheckType checkType)
        {
            SelectionItemPattern sip = (SelectionItemPattern)element.GetCurrentPattern(SelectionItemPattern.Pattern);

            if (sip == null)
                ThrowMe(checkType, "\"" + Library.GetUISpyLook(element) + " does not support SelectionItemPattern");

            return sip;
        }

        public static string GetDefaultName(string locationToCheck, string prefix, CheckType checkType = CheckType.Directory)
        {
            if (!Directory.Exists(locationToCheck))
                Directory.CreateDirectory(locationToCheck);

            IEnumerable<string> enumerable;

            if (checkType == CheckType.Directory)
                enumerable = Directory.EnumerateDirectories(locationToCheck);
            else
                enumerable = Directory.EnumerateFiles(locationToCheck);

            int[] projectNums = enumerable
                .Select(
                    dir =>
                    {
                        string name;

                        if (checkType == CheckType.Directory)
                        {
                            DirectoryInfo dirInfo = new DirectoryInfo(dir);
                            name = dirInfo.Name;
                        }
                        else
                        {
                            FileInfo fileInfo = new FileInfo(dir);
                            name = fileInfo.Name.Substring(0, fileInfo.Name.Length - fileInfo.Extension.Length);
                        }

                        string pattern = @"^" + prefix + @"(\d+)$";

                        if (!Regex.IsMatch(name, pattern))
                            return 0;

                        string value = Regex.Match(name, pattern).Groups[1].Value;

                        return int.Parse(value);
                    })
                .OrderBy(i => i).ToArray();

            int num = 1;
            foreach (int projectNum in projectNums)
            {
                if (projectNum == num)
                {
                    num++;
                }
                else
                {
                    break;
                }
            }
            string newName = prefix + num;
            return newName;
        }

        public static string CheckTypeToNotation(CheckType checkType)
        {
            switch (checkType)
            {
                case CheckType.Check:
                    return "+";
                case CheckType.CheckAndMate:
                    return "#";
            }

            return "";
        }

 private static bool GetByteForCheckType(CheckType checkType, ref byte val, IEnumerable<KeyValuePair<byte, CheckType>> dictionary)
 {
     foreach (var temp in dictionary)
     {
         if (temp.Value == checkType)
         {
             val = temp.Key;
             return true;
         }
     }
     return false;
 }

        private void ProcessStreamFlags()
        {
            byte[] streamFlags = _reader.ReadBytes(2);
            UInt32 crc = _reader.ReadLittleEndianUInt32();
            UInt32 calcCrc = Crc32.Compute(streamFlags);
            if (crc != calcCrc)
                throw new InvalidDataException("Stream header corrupt");

            BlockCheckType = (CheckType)(streamFlags[1] & 0x0F);
            byte futureUse = (byte)(streamFlags[1] & 0xF0);
            if (futureUse != 0 || streamFlags[0] != 0)
                throw new InvalidDataException("Unknown XZ Stream Version");
        }

 /// <summary>
 /// check to see if any checks in a subcategory match a given check
 /// </summary>
 /// <param name="subcategory"></param>
 /// <param name="type"></param>
 /// <param name="value"></param>
 /// <param name="contains"></param>
 /// <param name="equality"></param>
 /// <param name="invert"></param>
 /// <returns>true if there is a matching check in the category</returns>
 public static bool checkForCheckMatch(customSubCategory subcategory, CheckType type, string value, bool invert = false, bool contains = true, Check.Equality equality = Check.Equality.Equals)
 {
     for (int j = 0; j < subcategory.filters.Count; j++)
     {
         Filter f = subcategory.filters[j];
         for (int k = 0; k < f.checks.Count; k++)
         {
             Check c = f.checks[k];
             if (c.type == type && c.value == value && c.invert == invert && c.contains == contains && c.equality == equality)
                 return true;
         }
     }
     return false;
 }

 internal void pattern_Expand(Type expectedException, CheckType checkType)
 {
     string call = "Expand()";
     try
     {
         m_pattern.Expand();
         System.Threading.Thread.Sleep(1);
     }
     catch (Exception actualException)
     {
         TestException(expectedException, actualException, call, checkType);
         return;
     }
     TestNoException(expectedException, call, checkType);
 }

        /// -------------------------------------------------------------------
        /// <summary></summary>
        /// -------------------------------------------------------------------
        internal void patternToggle(Type expectedException, CheckType checkType)
        {
            string call = "Toggle()";
            try
            {
                _pattern.Toggle();
            }
            catch (Exception actualException)
            {
                if (Library.IsCriticalException(actualException))
                    throw;

                TestException(expectedException, actualException, call, checkType);
                return;
            }
            TestNoException(expectedException, call, checkType);
        }

 public CheckLogs(Employee employee, CheckType CheckType, DateTime temptime)
 {
     if (employee == null) throw new CheckLogsException();
     if (employee.Logs==null)
     {
         employee.Logs = new List<CheckLogs>();
     }
     //Remove Seconds
     //DateTime CheckTime = temptime.AddSeconds(-temptime.Second);
     DateTime CheckTime = temptime;
     this.CheckTime = CheckTime;
     this.CheckType = CheckType;
     _employee = employee;
     var _localtion = GPSHelper.GetInstance().GetLocation();
     x = Convert.ToDouble(_localtion.Latitude.ToString());
     y = Convert.ToDouble(_localtion.Longitude.ToString());
     employee.Logs.Add(this);
 }