public void Get_NoItemAdded_ReturnsNull()
        {
            var dd = new DataDictionary ();

            string res = dd.Get ("foobar");
            Assert.IsNull (res);
        }

 public Project() {
     Configuration = new ClientConfiguration();
     NotificationSettings = new Dictionary<string, NotificationSettings>();
     PromotedTabs = new HashSet<string>();
     DeleteBotDataEnabled = true;
     Data = new DataDictionary();
 }

        /// <summary>
        /// Configures the filtering dialog
        /// </summary>
        /// <param name="efsSystem"></param>
        /// <param name="filterConfiguration"></param>
        public void Configure(DataDictionary.EFSSystem efsSystem, FilterConfiguration filterConfiguration)
        {
            ruleActivationCheckBox.Checked = filterConfiguration.RuleFired;
            expectationsCheckBox.Checked = filterConfiguration.Expect;
            variableUpdateCheckBox.Checked = filterConfiguration.VariableUpdate;

            List<DataDictionary.Dictionary> dictionaries = new List<DataDictionary.Dictionary>(efsSystem.Dictionaries);
            dictionaries.Sort(compare);
            foreach (DataDictionary.Dictionary dictionary in dictionaries)
            {
                NamableTreeNode dictionaryTreeNode = new NamableTreeNode(dictionary);
                nameSpaceTreeView.Nodes.Add(dictionaryTreeNode);

                List<DataDictionary.Types.NameSpace> nameSpaces = new List<DataDictionary.Types.NameSpace>();
                foreach (DataDictionary.Types.NameSpace nameSpace in dictionary.NameSpaces)
                {
                    nameSpaces.Add(nameSpace);
                }
                nameSpaces.Sort();

                foreach (DataDictionary.Types.NameSpace nameSpace in nameSpaces)
                {
                    GatherNamespaces(dictionaryTreeNode, nameSpace, filterConfiguration);
                }
            }

            regExpTextBox.Text = filterConfiguration.RegExp;
        }

        /// <summary>
        /// Provides the set of covered requirements by the tests
        /// </summary>
        /// <param name="aDictionary">The model</param>
        /// <returns></returns>
        public static HashSet<DataDictionary.Specification.Paragraph> CoveredRequirements(DataDictionary.Dictionary aDictionary)
        {
            HashSet<DataDictionary.Specification.Paragraph> retVal = new HashSet<DataDictionary.Specification.Paragraph>();
            ICollection<DataDictionary.Specification.Paragraph> applicableParagraphs = aDictionary.Specifications.ApplicableParagraphs;
            Dictionary<DataDictionary.Specification.Paragraph, List<DataDictionary.ReqRef>> paragraphsReqRefDictionary = aDictionary.ParagraphsReqRefs;

            foreach (DataDictionary.Specification.Paragraph paragraph in applicableParagraphs)
            {
                bool implemented = paragraph.getImplementationStatus() == DataDictionary.Generated.acceptor.SPEC_IMPLEMENTED_ENUM.Impl_Implemented;
                bool tested = false;
                if (implemented)
                {
                    if (paragraphsReqRefDictionary.ContainsKey(paragraph))
                    {
                        List<DataDictionary.ReqRef> implementations = paragraphsReqRefDictionary[paragraph];
                        for (int i = 0; i < implementations.Count; i++)
                        {
                            DataDictionary.ReqRelated reqRelated = implementations[i].Enclosing as DataDictionary.ReqRelated;
                            if (reqRelated is TestCase && reqRelated.ImplementationCompleted == true)
                            {
                                tested = true;
                            }
                        }
                    }
                }

                if (implemented && tested)
                {
                    retVal.Add(paragraph);
                }
            }

            return retVal;
        }

        /// <summary>
        /// Takes the control state of the provided context and from it produces
        /// a view state model that is used as the basis of the view-step render
        /// pipeline.
        /// </summary>
        /// <remarks>
        /// This is what you'd override if you wanted to govern your own model presented
        /// to your view layer.
        /// </remarks>
        /// <param name="ev">The event that gave rise to this action.</param>
        public override void Action(IEvent ev)
        {
            DataDictionary<IData> model = new DataDictionary<IData> {
                ["messages"] = ev.Context.Messages,
                ["errors"] = ev.Context.Errors,
                ["flags"] = ev.Context.Flags,
                ["timers"] = ev.Context.Timers,
                ["params"] = new DataDictionary<string>(ev.Context.Params.Where(param => !param.Key.StartsWith("_")))
            };

            // copy from the context

            // copy from the control state
            foreach (KeyValuePair<string, object> entry in ev.Context.State) {
                if (!entry.Key.StartsWith("_")) { // exclude "private" items
                    if (entry.Value is IData) {
                        model[entry.Key] = entry.Value as IData;
                    } else {
                        model[entry.Key] = new TextData(entry.Value.ToString());
                    }
                }
            }

            if (ev.Context.HasParams("model-item") && model.ContainsKey(ev.Context.Params["model-item"])) {
                ev.Context.ViewSteps.CreateStep("view-state", model[ev.Context.Params["model-item"]]);
            } else {
                ev.Context.ViewSteps.CreateStep("view-state", model);
            }
        }

 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="efsSystem">The system for which this frame is built</param>
 public TestReport(DataDictionary.EFSSystem efsSystem)
 {
     InitializeComponent();
     reportHandler = new TestsCoverageReportHandler((Dictionary)null);
     TxtB_Path.Text = reportHandler.FileName;
     EFSSystem = efsSystem;
 }

        public static string ToFilterExpression(this DataFilter dataFilter,DataDictionary dataDictionary, string objectName)
        {
            StringBuilder filterUrl = new StringBuilder();
            DataObject dataObject = null;

            try
            {
                dataObject = dataDictionary.dataObjects.Find(x => x.objectName.ToUpper() == objectName.ToUpper());
                if (dataObject == null)
                {
                    throw new Exception("Data object not found.");
                }

                if (dataFilter != null && dataFilter.Expressions != null && dataFilter.Expressions.Count > 0)
                {
                    foreach (Expression expression in dataFilter.Expressions)
                    {
                        if (filterUrl.Length <= 0) // To avoid adding logical operator at starting.
                        {
                            expression.LogicalOperator = org.iringtools.library.LogicalOperator.None;
                        }

                        string sqlExpression = ResolveFilterExpression(dataObject, expression);
                        filterUrl.Append(sqlExpression);
                    }
                }
            }
            catch (Exception ex)
            {
                throw new Exception("Error generating filter url .", ex);
            }

            return filterUrl.ToString();
        }

 public Organization() {
     Invites = new Collection<Invite>();
     BillingStatus = BillingStatus.Trialing;
     Usage = new Collection<UsageInfo>();
     OverageHours = new Collection<UsageInfo>();
     Data = new DataDictionary();
 }

 /// <summary>
 /// Sets the explanation for this explain box
 /// </summary>
 /// <param name="explanation"></param>
 public void setExplanation(DataDictionary.Interpreter.ExplanationPart explanation)
 {
     explainTreeView.Nodes.Clear();
     ExplainTreeNode node = new ExplainTreeNode(explanation);
     innerSetExplanation(explanation, node, 0);
     explainTreeView.Nodes.Add(node);
 }

 /// <summary>
 /// Creates a section for all the (implemented) collections of the given namespace
 /// </summary>
 /// <param name="aNameSpace">The namespace</param>
 /// <param name="addDetails">Add details or simply enumerate the collections</param>
 /// <returns></returns>
 public void CreateCollectionsSection(DataDictionary.Types.NameSpace aNameSpace, bool addDetails)
 {
     if (countDisplayedReqRelated(aNameSpace.Collections) > 0)
     {
         AddSubParagraph("Collections");
         foreach (DataDictionary.Types.Collection collection in aNameSpace.Collections)
         {
             if (collection.ImplementationPartiallyCompleted == true)
             {
                 if (addDetails)
                 {
                     AddSubParagraph(collection.Name);
                     AddTable(new string[] { "Collection " + collection.Name }, new int[] { 40, 100 });
                     if (collection.Comment != "")
                     {
                         AddRow(collection.Comment);
                     }
                     AddRow("Type", collection.getTypeName());
                     AddRow("Default value", collection.Default);
                     AddRow("Max size", collection.getMaxSize().ToString());
                     CreateStatusTable(collection);
                     CloseSubParagraph();
                 }
                 else
                 {
                     AddParagraph(collection.Name + " (" + GetRequirementsAsString(collection.Requirements) + ")");
                 }
             }
         }
         CloseSubParagraph();
     }
 }

 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="item"></param>
 /// <param name="children"></param>
 public PreConditionsTreeNode(DataDictionary.Functions.Case item)
     : base(item, "Pre condition", true)
 {
     foreach (DataDictionary.Rules.PreCondition preCondition in item.PreConditions)
     {
         Nodes.Add(new DataDictionaryView.PreConditionTreeNode(preCondition));
     }
 }

        public async Task AddManualStackSignatureData(string dataKey, string dataValue, bool willAddManualStackSignature) {
            var plugin = new ManualStackingPlugin();
            var data = new DataDictionary() { { dataKey, dataValue } };
            var context = new EventContext(new PersistentEvent { Data = data });

            await plugin.EventBatchProcessingAsync(new List<EventContext> { context });
            Assert.Equal(willAddManualStackSignature, context.StackSignatureData.Count > 0);
        }

 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="specification"></param>
 public Window(DataDictionary.Dictionary dictionary)
 {
     InitializeComponent();
     FormClosed += new FormClosedEventHandler(Window_FormClosed);
     Visible = false;
     Dictionary = dictionary;
     Refresh();
 }

        /// <summary>
        /// Adds a new parameter
        /// </summary>
        /// <param name="function"></param>
        public ParameterTreeNode AddParameter(DataDictionary.Parameter parameter)
        {
            Item.appendParameters(parameter);
            ParameterTreeNode retVal = new ParameterTreeNode(parameter);
            Nodes.Add(retVal);

            return retVal;
        }

 /// <summary>
 /// Constructor (for function)
 /// </summary>
 /// <param name="item"></param>
 public ParametersTreeNode(DataDictionary.Functions.Function item)
     : base(item, "Parameters", true, false)
 {
     foreach (DataDictionary.Parameter parameter in item.FormalParameters)
     {
         Nodes.Add(new ParameterTreeNode(parameter));
     }
 }

        /// <summary>
        /// Adds a new case
        /// </summary>
        /// <param name="function"></param>
        public CaseTreeNode AddCase(DataDictionary.Functions.Case aCase)
        {
            Item.appendCases(aCase);
            CaseTreeNode retVal = new CaseTreeNode(aCase);
            Nodes.Add(retVal);

            return retVal;
        }

 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="item"></param>
 /// <param name="children"></param>
 public RulePreConditionsTreeNode(DataDictionary.Rules.RuleCondition item)
     : base(item, "Pre conditions", true, false)
 {
     foreach (DataDictionary.Rules.PreCondition preCondition in item.PreConditions)
     {
         Nodes.Add(new PreConditionTreeNode(preCondition));
     }
 }

        /// <summary>
        /// Adds a rule in this set of sub rules
        /// </summary>
        /// <param name="rule"></param>
        public void AddRule(DataDictionary.Rules.Rule rule)
        {
            Item.appendSubRules(rule);
            Nodes.Add(new RuleTreeNode(rule));
            SortSubNodes();

            Item.setVerified(false);
        }

 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="item"></param>
 /// <param name="name"></param>
 public CasesTreeNode(DataDictionary.Functions.Function item)
     : base(item, "Cases", true, false)
 {
     foreach (DataDictionary.Functions.Case aCase in item.Cases)
     {
         Nodes.Add(new CaseTreeNode(aCase));
     }
 }

 public void AddValue(DataDictionary.Constants.EnumValue value)
 {
     value.Name = "<EnumValue" + (GetNodeCount(false) + 1) + ">";
     value.setValue("");
     Item.appendValues(value);
     Nodes.Add(new EnumerationValueTreeNode(value));
     SortSubNodes();
 }