public override void Append(ErrorInfo error)
        {
            var pairs = new List<KeyValuePair<string, string>>();
            foreach (AssemblyPart ap in Deployment.Current.Parts)
            {
                StreamResourceInfo sri = Application.GetResourceStream(new Uri(ap.Source, UriKind.Relative));
                if (sri != null)
                {
                    Assembly assembly = new AssemblyPart().Load(sri.Stream);

                    pairs.Add(Message("Assembly", assembly.FullName));
                    pairs.Add(Message("ImageRuntimeVersion", assembly.ImageRuntimeVersion));

                    try
                    {
                        if (assembly.Location.Length != 0)
                        {
                            pairs.Add(Message("Location", assembly.Location));
                        }
                    }
                    catch
                    {
                    }
                }
            }
            error.AddDetail(this.Name, pairs);
        }

        public override void Append(ErrorInfo errorInfo)
        {
            var sb = new StringBuilder();
            Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
            foreach (Assembly assembly in assemblies)
            {
                sb.AppendLine(assembly.GetName().FullName);
            }
            sb.AppendLine();

            // Get file info
            foreach (Assembly assembly in assemblies)
            {
                bool flag = false;
                try
                {
                    if (assembly.Location.Length != 0)
                    {
                        sb.Append(FileVersionInfo.GetVersionInfo(assembly.Location).ToString());
                        flag = true;
                    }
                }
                catch(Exception)
                {
                }
                if (!flag)
                {
                    sb.Append(assembly.ToString());
                }
                sb.AppendLine();
            }
            errorInfo.AddDetail(this.Name, "", sb.ToString());
        }

        public void GetPropertyError(string propertyName, ErrorInfo info)
        {
            if (propertyName == "CustomerType" && string.IsNullOrEmpty(CustomerType))
            {
                info.ErrorText = "Please enter customer type";
            }
            if (propertyName == "CustomerName" && string.IsNullOrEmpty(CustomerName))
            {
                info.ErrorText = "Please enter customer name ";
            }
            if(propertyName=="MemberNo" && !string.IsNullOrEmpty(CustomerType))
            {
                if (CustomerType == "0")
                {
                     if(string.IsNullOrEmpty(MemberNo))
                    {
                        info.ErrorText = "Please enter member no ";  
                    }
                }
            }
            if (propertyName == "CustomerId" && string.IsNullOrEmpty(CustomerId))
            {
                info.ErrorText = "Please enter mobile no ";
            }
            else if (propertyName == "CustomerId" && !string.IsNullOrEmpty(CustomerId))
            {
               if (new BlCustomer().CheckCustomerId(CustomerId, CustomerNo))
               {
                   info.ErrorText = "Duplicate mobile no ";
               }
            }
            


        }

        public override void Append(ErrorInfo errorInfo)
        {
            Assembly assembly = errorInfo.GetType().Assembly;

            var pairs = new Dictionary<string, string>();
            pairs.Add("Date", DateTime.Now.ToString());
            pairs.Add("Culture", CultureInfo.CurrentCulture.Name);

            #if !SILVERLIGHT

            pairs.Add("User", string.Format(CultureInfo.InvariantCulture, @"{0}\{1}", Environment.UserDomainName, Environment.UserName).Trim('\\'));
            pairs.Add("Machine Name", Environment.MachineName);
            pairs.Add("App Start Time", Process.GetCurrentProcess().StartTime.ToLocalTime().ToString(CultureInfo.InvariantCulture));
            pairs.Add("App Up Time", (DateTime.Now - Process.GetCurrentProcess().StartTime.ToLocalTime()).ToString());
            pairs.Add("Worker process", GetWorkerProcess());
            pairs.Add("AppDomain", AppDomainDetail(AppDomain.CurrentDomain));
            pairs.Add("Deployment", (assembly.GlobalAssemblyCache) ? "GAC" : "bin");

            #endif
            pairs.Add("Thread Id", Thread.CurrentThread.ManagedThreadId.ToString(CultureInfo.InvariantCulture));
            pairs.Add("Full Name", new AssemblyName(assembly.FullName).FullName);
            pairs.Add("Operating System Version", Environment.OSVersion.ToString());
            pairs.Add("Common Language Runtime Version", Environment.Version.ToString());
            pairs.Add("Elmah.Everywhere Version", new AssemblyName(typeof(Diagnostics.ExceptionHandler).Assembly.FullName).Version.ToString());

            errorInfo.AddDetail(this.Name, pairs);
        }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="plcVarName"></param>
 /// <returns>ture added, false removed</returns>
 public Boolean IsWarnningAdded( ErrorInfo info)
 {
     Boolean result = false;
     if(info != null){
         result = mSortedWarnningMap.ContainsKey(info.level);
     }
     return  result;
 }

        public void Appenders_Is_Null_Test()
        {
            // Act
            ErrorInfo error = new ErrorInfo();

            // Assert
            Assert.Null(error.Appenders);
        }

 public override void Append(ErrorInfo errorInfo)
 {
     var memorystatusex = new MemoryStatusEx();
     if (NativeMethods.GlobalMemoryStatusEx(memorystatusex))
     {
         errorInfo.AddDetail(this.Name, "Total Memory", string.Format(CultureInfo.InvariantCulture, "{0} MB", memorystatusex.ullTotalPhys / (1024 * 1024)));
         errorInfo.AddDetail(this.Name, "Available Memory", string.Format(CultureInfo.InvariantCulture, "{0} MB", memorystatusex.ullAvailPhys / (1024 * 1024)));
     }
 }

 void IDXDataErrorInfo.GetError(ErrorInfo info)
 {
     if (StartDate > EndDate)
     {
         SetErrorInfo(info,
             "Either StartDate or EndDate should be corrected.",
             ErrorType.Critical);
     }
 }

 /************************************************************************/
 /************************************************************************/
 public static int IsError(ErrorInfo e)
 {
     if (e.Value != 0)
     {
         MessageBox.Show(e.Message);
         return 1;
     }
     return 0;
 }

        /// <summary>
        /// Add an error to the ErrorCollection.
        /// </summary>
        /// <param name="lineNumber">The line when the error occurs.</param>
        /// <param name="ex">The exception thrown, can be null.</param>
        /// <param name="recordLine">The record values</param>
        protected void AddError(int lineNumber, Exception ex, string recordLine)
        {
            ErrorInfo e = new ErrorInfo();
            e.mLineNumber = lineNumber;
//			e.mColumnNumber = colNum;
            e.mExceptionInfo = ex;
            e.mRecordString = recordLine;

            mErrorManager.AddError(e);
        }

 public void GetPropertyError(string propertyName, ErrorInfo info)
 {
     if (propertyName == "Username" && string.IsNullOrEmpty(Username)
         || propertyName == "Fullname" && string.IsNullOrWhiteSpace(Fullname)
         || propertyName == "Empno" && string.IsNullOrEmpty(Empno)
         || propertyName == "Password" && string.IsNullOrEmpty(Password)
         || propertyName == "Role" && string.IsNullOrEmpty(Role)
         || propertyName == "Password1" && string.IsNullOrEmpty(Password1)
         || propertyName == "Profileid" && string.IsNullOrEmpty(Profileid))
         info.ErrorText = String.Format("The '{0}' field cannot be empty", propertyName);
 }

        public override void Append(ErrorInfo errorInfo)
        {
            var pairs = new Dictionary<string, string>();
            pairs.Add("CellularMobileOperator", DeviceNetworkInformation.CellularMobileOperator);
            pairs.Add("IsCellularDataEnabled", DeviceNetworkInformation.IsCellularDataEnabled.ToString());
            pairs.Add("IsCellularDataRoamingEnabled", DeviceNetworkInformation.IsCellularDataRoamingEnabled.ToString());
            pairs.Add("IsNetworkAvailable", DeviceNetworkInformation.IsNetworkAvailable.ToString());
            pairs.Add("IsWiFiEnabled", DeviceNetworkInformation.IsWiFiEnabled.ToString());

            errorInfo.AddDetail(this.Name, pairs);
        }

        public void BuildMessage_Returns_Error_Detail_Message_If_ErrorDetails_Are_Empty_Test()
        {
            // Arrange
            ErrorInfo error = new ErrorInfo(new Exception());

            // Act
            string detail = error.BuildMessage();

            // Assert
            Assert.Equal(error.Detail, detail);
        }

        /// <summary>
        /// Attempts to get a statfs struct for a given mount point.
        /// </summary>
        /// <param name="name">The drive name to retrieve the statfs data for.</param>
        /// <param name="data">The data retrieved from the mount point.</param>
        /// <returns>Returns true if data was filled with the results; otherwise, false.</returns>
        internal static bool TryGetStatFsForDriveName(string name, out statfs data, out ErrorInfo errorInfo)
        {
            data = default(statfs);
            if (get_statfs(name, out data) < 0)
            {
                errorInfo = Interop.Sys.GetLastErrorInfo();
                return false;
            }

            errorInfo = default(ErrorInfo);
            return true;
        }

        public void AddWarningItem(ErrorInfo info)
        {
            int key = info.level;
            mSortedWarnningMap.Add(key, info);

            //reorder warning
            mWarnningList.Clear();
            mWarnningList = mSortedWarnningMap.Values.ToList();
            mWarnningList.Add(ERROEINFO_NORMAL);

            Warnning.write(info);
        }

 public override void Append(ErrorInfo error)
 {
     if (error.Properties != null && error.Properties.Count > 0)
     {
         var pairs = new Dictionary<string, string>();
         foreach (var key in error.Properties.Keys)
         {
             pairs.Add(key, error.Properties[key].ToString());
         }
         error.AddDetail(this.Name, pairs);
     }
 }

        public void LogException_ErrorInfo_Test()
        {
            // Arrange
            TestableElmahErrorHelper helper = new TestableElmahErrorHelper();

            ErrorInfo info = new ErrorInfo();

            // Act
            helper.LogException(info);

            // Assert
            Assert.NotNull(helper.Error);
        }

        public void Shoult_Append_Properties_Test()
        {
            // Arrange
            PropertiesAppender appender = new PropertiesAppender();
            ErrorInfo error = new ErrorInfo(new Exception("Test-Exception"));
            error.Properties = new Dictionary<string, object>();
            error.Properties.Add("Key", "Value");

            // Act
            appender.Append(error);

            // Act
            Assert.Equal(error.ErrorDetails.Single().Name, appender.Name);
        }

    /// <summary>
    /// Gets an Exception to represent the supplied error info.
    /// </summary>
    /// <param name="error">The error info</param>
    /// <param name="path">The path with which this error is associated.  This may be null.</param>
    /// <param name="isDirectory">true if the <paramref name="path"/> is known to be a directory; otherwise, false.</param>
    /// <returns></returns>
    internal static Exception GetExceptionForIoErrno(ErrorInfo errorInfo, string path = null, bool isDirectory = false)
    {
        switch (errorInfo.Error)
        {
            case Error.ENOENT:
                if (isDirectory)
                {
                    return !string.IsNullOrEmpty(path) ?
                        new DirectoryNotFoundException(SR.Format(SR.IO_PathNotFound_Path, path)) :
                        new DirectoryNotFoundException(SR.IO_PathNotFound_NoPathName);
                }
                else
                {
                    return !string.IsNullOrEmpty(path) ?
                        new FileNotFoundException(SR.Format(SR.IO_FileNotFound_FileName, path), path) :
                        new FileNotFoundException(SR.IO_FileNotFound);
                }

            case Error.EACCES:
            case Error.EBADF:
            case Error.EPERM:
                return !string.IsNullOrEmpty(path) ?
                    new UnauthorizedAccessException(SR.Format(SR.UnauthorizedAccess_IODenied_Path, path)) :
                    new UnauthorizedAccessException(SR.UnauthorizedAccess_IODenied_NoPathName);

            case Error.ENAMETOOLONG:
                return new PathTooLongException(SR.IO_PathTooLong);

            case Error.EWOULDBLOCK:
                return !string.IsNullOrEmpty(path) ?
                    new IOException(SR.Format(SR.IO_SharingViolation_File, path), errorInfo.RawErrno) :
                    new IOException(SR.IO_SharingViolation_NoFileName, errorInfo.RawErrno);

            case Error.ECANCELED:
                return new OperationCanceledException();

            case Error.EFBIG:
                return new ArgumentOutOfRangeException("value", SR.ArgumentOutOfRange_FileLengthTooBig);

            case Error.EEXIST:
                if (!string.IsNullOrEmpty(path))
                {
                    return new IOException(SR.Format(SR.IO_FileExists_Name, path), errorInfo.RawErrno);
                }
                goto default;

            default:
                return GetIOException(errorInfo);
        }
    }

        public void BuildMessage_Appends_Details()
        {
            // Arrange
            ErrorInfo error = new ErrorInfo(new Exception());
            var pair = new List<KeyValuePair<string, string>>();
            pair.Add(new KeyValuePair<string, string>("Key", "Value"));

            error.AddDetail("Append Test", pair);

            // Act
            string detail = error.BuildMessage();

            // Assert
            Assert.True(detail.Contains("Append Test"));
        }