public void MatchValue()
 {
     ApplicationData postedData = new ApplicationData { { "First_name", "Superman" } };
     ApplicationData applicationData = new ApplicationData();
     bool result = this.evaluator.Evaluate(this.condition, this.ControlList, postedData, applicationData, this.EvaluatorRegister);
     Assert.IsTrue(result);
 }

 /// <summary>
 /// Creates a new <see cref="TransactionVariables"/>.
 /// </summary>
 /// <param name="formId">The form id.</param>
 /// <param name="applicationId">The application id.</param>
 /// <param name="applicationData">The application data.</param>
 /// <returns>A new <see cref="TransactionVariables"/>.</returns>
 public TransactionVariables Create(string formId, string applicationId, ApplicationData applicationData)
 {
     ExpressionEvaluator evaluator = new ExpressionEvaluator(new Application(null, formId, null, applicationId, applicationData));
     double amountValue = evaluator.Evaluate<double>(this.AmountExpression);
     string referenceValue = evaluator.Evaluate<string>(this.ReferenceExpression);
     return new TransactionVariables(this.MerchantPassword, amountValue, referenceValue);
 }

 public void NotMatchNonEmptyStringValue()
 {
     ApplicationData postedData = new ApplicationData { { "First_name", "AmazingMan" } };
     ApplicationData applicationData = new ApplicationData();
     bool result = this.evaluator.Evaluate(this.condition, this.ControlList, postedData, applicationData, this.EvaluatorRegister);
     Assert.IsTrue(result);
 }

 public void MatchValueWithSpaces()
 {
     ApplicationData postedData = new ApplicationData { { "First_name", "Amazing Man" } };
     ApplicationData applicationData = new ApplicationData();
     bool result = this.evaluator.Evaluate(this.condition, this.ControlList, postedData, applicationData, this.EvaluatorRegister);
     Assert.IsFalse(result);
 }

 public void GreaterThanValue()
 {
     ApplicationData postedData = new ApplicationData { { "First_name", "Mix" } };
     ApplicationData applicationData = new ApplicationData();
     bool result = this.evaluator.Evaluate(this.condition, this.ControlList, postedData, applicationData, this.EvaluatorRegister);
     Assert.IsFalse(result);
 }

 public void LessThanDoubleValue()
 {
     ApplicationData postedData = new ApplicationData { { "Age", "49.5" } };
     ApplicationData applicationData = new ApplicationData();
     bool result = this.evaluator.Evaluate(this.condition, this.ControlList, postedData, applicationData, this.EvaluatorRegister);
     Assert.IsTrue(result);
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="Application"/> class.
 /// </summary>
 /// <param name="organisationId">The organisation id.</param>
 /// <param name="formId">The form id.</param>
 /// <param name="formVersion">The form version number.</param>
 /// <param name="applicationId">The application id.</param>
 /// <param name="applicationData">The application data.</param>
 public Application(string organisationId, string formId, int? formVersion, string applicationId = null, ApplicationData applicationData = null)
     : this(applicationData, applicationId)
 {
     this.OrganisationId = organisationId;
     this.FormId = formId;
     this.FormVersion = formVersion;
 }

 public void FieldMissing()
 {
     ApplicationData postedData = new ApplicationData();
     ApplicationData applicationData = new ApplicationData();
     bool result = this.evaluator.Evaluate(this.condition, this.ControlList, postedData, applicationData, this.EvaluatorRegister);
     Assert.IsFalse(result);
 }

        public void TestControlName()
        {
            string json = AssemblyResourceReader.ReadAsString("Test_Data.ValidateRule1.json");
            ValidateTruthCondition condition = JsonConvert.DeserializeObject<ValidateTruthCondition>(json);

            ControlList controlList = new ControlList();
            RepeaterControl repeater = new RepeaterControl
                                       { Id = 3, Name = "Repeater" };
            controlList.Add(repeater);
            repeater.Controls.Add(new TextControl { Id = 1, Name = "Field1", ParentId = 3 });
            repeater.Controls.Add(new TextControl { Id = 2, Name = "Field2", ParentId = 3 });

            ApplicationData appData = new ApplicationData();
            Dictionary<string, object>[] repeaterData = new Dictionary<string, object>[2];
            appData.Add("Repeater", repeaterData);
            repeaterData[0] = new Dictionary<string, object>
                              {
                                  { "Field1", "Is Valid" },
                                  { "Field2", "When Combined With This" }
                              };
            repeaterData[1] = new Dictionary<string, object>
                              {
                                  { "Field1", "Not Valid" },
                                  { "Field2", "When Combined With This" }
                              };

            TruthConditionEvaluatorFactory evaluatorFactory = new TruthConditionEvaluatorFactory();

            ITruthConditionValidator validator = new ITruthConditionValidator(condition, controlList, evaluatorFactory);
            ValidationResults results = validator.Validate(appData);
            Assert.AreEqual("Repeater[1].Field1", results.ToArray()[0].Key);
        }

 public void DoesNotExist()
 {
     ApplicationData postedData = new ApplicationData();
     ApplicationData applicationData = new ApplicationData { { "First_name", "Batman" } };
     bool result = this.evaluator.Evaluate(this.condition, this.ControlList, postedData, applicationData, this.EvaluatorRegister);
     Assert.IsFalse(result);
 }

 public void MatchValueCaseDifferent()
 {
     ApplicationData postedData = new ApplicationData { { "First_name", "spIdERmAn" } };
     ApplicationData applicationData = new ApplicationData();
     bool result = this.evaluator.Evaluate(this.condition, this.ControlList, postedData, applicationData, this.EvaluatorRegister);
     Assert.IsFalse(result);
 }

 public void LatitudeGreaterThanDoubleValue()
 {
     ApplicationData postedData = new ApplicationData { { "Geolocation", "100,300" } };
     ApplicationData applicationData = new ApplicationData();
     bool result = this.evaluatorLat.Evaluate(this.conditionLat, this.ControlList, postedData, applicationData, this.EvaluatorRegister);
     Assert.IsTrue(result);
 }

 public void LongitudeLessThanDoubleValue()
 {
     ApplicationData postedData = new ApplicationData { { "Geolocation", "300,49.5" } };
     ApplicationData applicationData = new ApplicationData();
     bool result = this.evaluatorLong.Evaluate(this.conditionLong, this.ControlList, postedData, applicationData, this.EvaluatorRegister);
     Assert.IsFalse(result);
 }

        public void RepeaterHideRuleReferenceRootControl()
        {
            ITruthCondition condition = new HideTruthCondition { RuleType = "HIDE" };
            TruthConditionList subRuleList = new TruthConditionList();
            CompareDefinition compareDefinition = new CompareDefinition { CompareTo = ComparisonType.Value, Field = "Checkbox", FieldScope = FieldScope.Unknown, Operator = Operator.Equals, Value = "checked" };
            subRuleList.Add(new CompareTruthCondition { RuleType = "EVAL", Value = compareDefinition });
            condition.Value = subRuleList;

            ControlList controlList = new ControlList { new CheckboxControl { Name = "Checkbox" } };
            RepeaterControl repeater = new RepeaterControl { Name = "Parent" };
            repeater.AddChild(new ComboControl { Name = "Child", VisibilityRule = condition });
            controlList.Add(repeater);

            ApplicationData applicationData = new ApplicationData { { "Checkbox", "checked" } };
            Dictionary<string, object>[] repeaterValue = new Dictionary<string, object>[1];
            repeaterValue[0] = new Dictionary<string, object>();
            repeaterValue[0]["Child"] = string.Empty;
            applicationData.Add("Parent", repeaterValue);

            ITruthConditionEvaluator<ITruthCondition> evaluator = this.EvaluatorRegister.GetEvaluatorFor<HideTruthCondition>();
            bool result = evaluator.Evaluate(condition, controlList, applicationData, null, this.EvaluatorRegister, "Parent[0]");
            Assert.IsTrue(result);

            applicationData["Checkbox"] = string.Empty;
            result = evaluator.Evaluate(condition, controlList, applicationData, null, this.EvaluatorRegister, "Parent[0]");
            Assert.IsFalse(result);
        }

 public void TestSerializeCheckboxGroup()
 {
     ApplicationData application = new ApplicationData { { "CheckboxGroupControl", new[] { "one", "three" } } };
     string json = JsonConvert.SerializeObject(application, Formatting.None);
     const string expected = "{\"CheckboxGroupControl\":[\"one\",\"three\"]}";
     Assert.AreEqual(expected, json);
 }

 public void EmptyArrays()
 {
     ITruthCondition localCondition = JsonConvert.DeserializeObject<ITruthCondition>(this.GetTestResource("ConditionIn.empty.json"), new JsonKnownTypeConverter());
     ApplicationData postedData = new ApplicationData { { "First_name", new string[] { } } };
     ApplicationData applicationData = new ApplicationData();
     bool result = this.evaluator.Evaluate(localCondition, this.ControlList, postedData, applicationData, this.EvaluatorRegister);
     Assert.IsTrue(result);
 }

            public void SetsApplicationIdAndApplicationData()
            {
                ApplicationData data = new ApplicationData { { "Foo", "Bar" } };
                Application application = new Application(applicationId: "52ddb25d606fdc049c7aaf7e", applicationData: data);

                Assert.AreEqual("52ddb25d606fdc049c7aaf7e", application.Id);
                Assert.AreEqual("Bar", application.ApplicationData["Foo"]);
            }

 public void ControlHasBogusRule()
 {
     ControlList controlList = JsonConvert.DeserializeObject<ControlList>(this.GetTestResource("BogusRule.json"), new JsonKnownTypeConverter());
     ApplicationData postedData = new ApplicationData();
     GroupControl control = controlList.FindRecursive<GroupControl>(1);
     bool visible = control.IsVisible(controlList, postedData, null, this.register);
     Assert.IsTrue(visible);
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="ApplicationWorkflowItem"/> class.
 /// </summary>
 /// <param name="postedApplication">The updated <see cref="Application"/> containing
 /// the posted <see cref="ApplicationData"/>.</param>
 /// <param name="existingData">The existing <see cref="ApplicationData"/>. Defaults to <see langword="null"/>.</param>
 /// <param name="controlList">The controls. Defaults to <see langword="null"/>.</param>
 public ApplicationWorkflowItem(Application postedApplication, ApplicationData existingData = null, ControlList controlList = null)
     : this(postedApplication.FormId, postedApplication.LastEditBy)
 {
     this.ApplicationId = postedApplication.ApplicationId;
     this.VersionNumber = postedApplication.VersionNumber;
     this.PostedData = postedApplication.ApplicationData;
     this.ExistingData = existingData;
     this.ControlList = controlList;
 }

            public void ContinueAfterShownControl()
            {
                ApplicationData applicationData = new ApplicationData();
                applicationData.SetValue("Hide_trigger", "No", true);

                ValidationResults results = new ValidationResults();
                this.validator.Validate(applicationData, results);
                Assert.AreEqual(false, results.IsValid);
            }