void ValidateParameters(Common.ParametersValidation validationRequest, ref string logMessage, ref bool passed, XmlNode test)
        {
            foreach (Common.ValidationRule rule in validationRequest.ValidationRules)
            {
                string parameterPath = string.Format("RequestParameters/{0}", rule.ParameterPath);

                switch (rule.Type)
                {
                case ParameterType.String:
                    CommonCompare.StringCompare(parameterPath, rule.ParameterName, (string)rule.Value,
                                                ref logMessage, ref passed, test);
                    break;

                case ParameterType.Int:
                    CommonCompare.IntCompare(parameterPath, rule.ParameterName, (int)rule.Value,
                                             ref logMessage, ref passed, test);
                    break;

                case ParameterType.OptionalInt:
                    int?value = (int?)rule.Value;
                    if (CommonCompare.Exist2(parameterPath, rule.ParameterName, value.HasValue, ref logMessage, ref passed, test))
                    {
                        CommonCompare.IntCompare(parameterPath, rule.ParameterName, value.Value, ref logMessage, ref passed, test);
                    }
                    break;

                case ParameterType.OptionalBool:
                    if (rule.ValueSpecified)
                    {
                        CommonCompare.StringCompare(parameterPath, rule.ParameterName, ((bool)rule.Value).ToString(),
                                                    ref logMessage, ref passed, test);
                    }
                    else
                    {
                        CommonCompare.Exist2(parameterPath, rule.ParameterName, rule.ValueSpecified,
                                             ref logMessage, ref passed, test);
                    }
                    break;

                case ParameterType.OptionalString:
                {
                    string stringValue = (string)rule.Value;
                    if (CommonCompare.Exist2(parameterPath, rule.ParameterName, stringValue != null, ref logMessage, ref passed, test))
                    {
                        CommonCompare.StringCompare(parameterPath, rule.ParameterName, (string)rule.Value,
                                                    ref logMessage, ref passed, test);
                    }
                }
                break;

                case ParameterType.OptionalElement:
                {
                    CommonCompare.Exist2(parameterPath, rule.ParameterName, rule.Value != null, ref logMessage, ref passed, test);
                }
                break;

                case ParameterType.OptionalElementBoolFlag:
                {
                    CommonCompare.Exist2(parameterPath, rule.ParameterName, (bool)rule.Value, ref logMessage, ref passed, test);
                }
                break;

                case ParameterType.StringArray:
                {
                    CommonCompare.StringArrayCompare(parameterPath, rule.ParameterName, (string[])rule.Value,
                                                     ref logMessage, ref passed, test);
                }
                break;

                case ParameterType.Log:
                {
                    if (rule.Value.GetType().ToString() == "System.Byte[]")
                    {
                        logMessage = logMessage + rule.ParameterName + " = [Check it manually!]";
                    }
                    else
                    {
                        logMessage = logMessage + rule.ParameterName + " = " + rule.Value.ToString();
                    }
                }
                break;

                case ParameterType.OptionalQName:
                {
                    XmlQualifiedName QNameValue = (XmlQualifiedName)rule.Value;
                    if (CommonCompare.Exist2(parameterPath, rule.ParameterName, QNameValue != null, ref logMessage, ref passed, test))
                    {
                        CommonCompare.StringCompare(parameterPath + "/Namespace", rule.ParameterName + "/Namespace", QNameValue.Namespace,
                                                    ref logMessage, ref passed, test);
                        CommonCompare.StringCompare(parameterPath + "/Name", rule.ParameterName + "/Name", QNameValue.Name,
                                                    ref logMessage, ref passed, test);
                    }
                }
                break;

                case ParameterType.X509Cert:
                {
                    Org.BouncyCastle.X509.X509Certificate cert = (new Org.BouncyCastle.X509.X509CertificateParser()).ReadCertificate((byte[])rule.Value);
                    logMessage = logMessage + "\r\n";
                    logMessage = logMessage + rule.ParameterName + ": " + "\r\n" + cert.ToString();
                    logMessage = logMessage + "\r\n";
                    //TextWriter textWriter = new StringWriter();
                    //Org.BouncyCastle.Utilities.IO.Pem.PemWriter pemWriter = new Org.BouncyCastle.Utilities.IO.Pem.PemWriter(textWriter);
                    //pemWriter.WriteObject(cert.CertificateStructure.SubjectPublicKeyInfo.PublicKeyData);
                    //pemWriter.Writer.Flush();

                    //string privateKey = textWriter.ToString();
                    logMessage = logMessage + rule.ParameterName + "(PubK): " + "\r\n" + cert.CertificateStructure.SubjectPublicKeyInfo.PublicKeyData.ToString();
                    logMessage = logMessage + "\r\n";
                    logMessage = logMessage + rule.ParameterName + "(SignatureAlgorithm): " + "\r\n" + cert.CertificateStructure.SignatureAlgorithm.ObjectID.ToString();
                    logMessage = logMessage + "\r\n";
                }
                break;

                case ParameterType.PKCS10:
                {
                    Org.BouncyCastle.Pkcs.Pkcs10CertificationRequest pkcs10 = new Org.BouncyCastle.Pkcs.Pkcs10CertificationRequest((byte[])rule.Value);
                    logMessage = logMessage + "\r\n";
                    logMessage = logMessage + rule.ParameterName + ": " + "\r\n" + pkcs10.ToString();
                    logMessage = logMessage + "\r\n";
                }
                break;

                case ParameterType.PKCS12WithoutPassphrase:
                {
                    Org.BouncyCastle.Pkcs.Pkcs12Store pkcs12Store = new Org.BouncyCastle.Pkcs.Pkcs12Store();
                    pkcs12Store.Load(new MemoryStream((byte[])rule.Value), ("").ToArray());

                    logMessage = logMessage + rule.ParameterName + ": " + "\r\n";


                    foreach (string alias in pkcs12Store.Aliases)
                    {
                        logMessage = logMessage + "\r\n";
                        logMessage = logMessage + "Alias = " + alias + "\r\n";
                        logMessage = logMessage + "Certificate = " + pkcs12Store.GetCertificate(alias).Certificate.ToString();
                    }

                    logMessage = logMessage + "\r\n";
                }
                break;

                case ParameterType.CRL:
                {
                    Org.BouncyCastle.X509.X509Crl crl = (new Org.BouncyCastle.X509.X509CrlParser()).ReadCrl((byte[])rule.Value);
                    logMessage = logMessage + "\r\n";
                    logMessage = logMessage + rule.ParameterName + ": " + "\r\n" + crl.ToString();
                    logMessage = logMessage + "\r\n";
                }
                break;

                case ParameterType.Float:
                {
                    CommonCompare.FloatCompare(parameterPath, rule.ParameterName, (float)rule.Value,
                                               ref logMessage, ref passed, test);
                }
                break;

                case ParameterType.OptionalFloat:
                    float?fvalue = (float?)rule.Value;
                    if (CommonCompare.Exist2(parameterPath, rule.ParameterName, fvalue.HasValue, ref logMessage, ref passed, test))
                    {
                        CommonCompare.FloatCompare(parameterPath, rule.ParameterName, (float)rule.Value,
                                                   ref logMessage, ref passed, test);
                    }
                    break;
                }
            }
        }