public void FetchFromList_Expected_NonNullDisplayName()
        {
            string error;

            IBinaryDataList dl1;

            dl1 = Dev2BinaryDataListFactory.CreateDataList();

            IList <Dev2Column> cols = new List <Dev2Column>();

            cols.Add(Dev2BinaryDataListFactory.CreateColumn("field1"));

            dl1.TryCreateRecordsetTemplate("recset", "", cols, true, out error);

            dl1.TryCreateRecordsetValue("value", "field1", "recset", 1, out error);

            IBinaryDataListEntry entry;

            dl1.TryGetEntry("recset", out entry, out error);

            // DataList Cleanup ;)

            Assert.AreEqual("recset(1).field1", entry.FetchRecordAt(1, out error).First().DisplayValue);
            Assert.AreEqual(error, "");
        }
Esempio n. 2
0
        public void UpperFirst_StringContainingNumerics_Expected_All_FirstLetterUpperCase()
        {
            IBinaryDataListItem item   = Dev2BinaryDataListFactory.CreateBinaryItem("5make1 1first 3letter up5percase", "");
            IBinaryDataListItem result = converter.TryConvert("Sentence", item);

            Assert.AreEqual("5make1 1first 3letter up5percase", result.TheValue);
        }
Esempio n. 3
0
        /// <summary>
        ///     Converts a list of data list item view models to a binary data list.
        /// </summary>
        /// <param name="errorString">The error string.</param>
        /// <returns></returns>
        private IBinaryDataList ConvertIDataListItemModelsToIBinaryDataList(out string errorString)
        {
            errorString = string.Empty;
            IBinaryDataList result = Dev2BinaryDataListFactory.CreateDataList();

            IList <IDataListItemModel> filledScalars =
                ScalarCollection != null?ScalarCollection.Where(scalar => !scalar.IsBlank && !scalar.HasError).ToList() : new List <IDataListItemModel>();

            foreach (var scalar in filledScalars)
            {
                result.TryCreateScalarTemplate
                    (string.Empty, scalar.Name, scalar.Description
                    , true, scalar.IsEditable, scalar.ColumnIODirection, out errorString);
            }

            foreach (var recset in RecsetCollection ?? new OptomizedObservableCollection <IDataListItemModel>())
            {
                if (recset.IsBlank)
                {
                    continue;
                }
                IEnumerable <IDataListItemModel> filledRecordSets = recset.Children.Where(c => !c.IsBlank && !c.HasError);
                IList <Dev2Column> cols = filledRecordSets.Select(child => DataListFactory.CreateDev2Column(child.Name, child.Description, child.IsEditable, child.ColumnIODirection))
                                          .ToList();

                result.TryCreateRecordsetTemplate(recset.Name, recset.Description, cols, true, recset.IsEditable, recset.ColumnIODirection, out errorString);
            }

            return(result);
        }
Esempio n. 4
0
        public void TitleCase_StringWithNumeric_Expected_All_FirstLetterUpperCaseOnAll()
        {
            IBinaryDataListItem item   = Dev2BinaryDataListFactory.CreateBinaryItem("1make fi5rst le6tter up3percase", "");
            IBinaryDataListItem result = converter.TryConvert("Title Case", item);

            Assert.AreEqual("1make Fi5rst Le6tter Up3percase", result.TheValue);
        }
Esempio n. 5
0
        public void AllUpper_Complex_String_Expected_All_UpperCase()
        {
            IBinaryDataListItem item   = Dev2BinaryDataListFactory.CreateBinaryItem("string.(to)@ 'make' u//ppercase", "");
            IBinaryDataListItem result = converter.TryConvert("UPPER", item);

            Assert.AreEqual("STRING.(TO)@ 'MAKE' U//PPERCASE", result.TheValue);
        }
Esempio n. 6
0
        public void DeSerializeToXMLInputsOnlyFromBinary_ValidXML_Expect_Sucess()
        {
            IBinaryDataList   dl    = Dev2BinaryDataListFactory.CreateDataList();
            List <Dev2Column> cols1 = new List <Dev2Column>
            {
                DataListFactory.CreateDev2Column("f1", ""),
            };
            List <Dev2Column> cols2 = new List <Dev2Column>
            {
                DataListFactory.CreateDev2Column("f2", ""),
            };
            string        error;
            ErrorResultTO errors;


            IDataListTranslator xmlConverter = Dls.GetTranslator(XmlFormatInputsOnly);

            dl.TryCreateRecordsetTemplate("rs1", "", cols1, true, out error);
            dl.TryCreateRecordsetTemplate("rs2", "", cols2, true, true, enDev2ColumnArgumentDirection.Input, out error);
            dl.TryCreateScalarTemplate("", "scalar1", "", true, true, enDev2ColumnArgumentDirection.Input, out error);
            dl.TryCreateScalarTemplate("", "scalar2", "", true, true, enDev2ColumnArgumentDirection.Output, out error);
            dl.TryCreateScalarValue("scalar1Value", "scalar1", out error);
            dl.TryCreateScalarValue("scalar2Value", "scalar2", out error);
            dl.TryCreateRecordsetValue("rec1.f1.value", "f1", "rs1", 1, out error);
            dl.TryCreateRecordsetValue("rec1.f2.value", "f2", "rs2", 1, out error);
            dl.TryCreateRecordsetValue("rec2.f1.value", "f1", "rs1", 2, out error);
            dl.TryCreateRecordsetValue("rec2.f2.value", "f2", "rs2", 2, out error);

            DataListTranslatedPayloadTO tmp = xmlConverter.ConvertFrom(dl, out errors);

            string result = tmp.FetchAsString().ToString();

            Assert.AreEqual("<DataList><scalar1>scalar1Value</scalar1></DataList>", result);
        }
Esempio n. 7
0
        public void DeSerializeToXMLFromBinary_InvertedIndexInsert_ValidXML_Expect_Sucess()
        {
            IBinaryDataList   dl = Dev2BinaryDataListFactory.CreateDataList();
            string            error;
            List <Dev2Column> cols = new List <Dev2Column>();
            ErrorResultTO     errors;

            cols.Add(DataListFactory.CreateDev2Column("f1", ""));
            cols.Add(DataListFactory.CreateDev2Column("f2", ""));
            cols.Add(DataListFactory.CreateDev2Column("f3", ""));
            IDataListTranslator xmlConverter = Dls.GetTranslator(XmlFormat);


            dl.TryCreateRecordsetTemplate("rs1", "", cols, true, out error);
            dl.TryCreateScalarTemplate(string.Empty, "scalar1", "", true, out error);
            dl.TryCreateScalarValue("scalar1Value", "scalar1", out error);
            dl.TryCreateRecordsetValue("rec1.f2.vale", "f2", "rs1", 1, out error);
            dl.TryCreateRecordsetValue("rec1.f1.vale", "f1", "rs1", 1, out error);
            dl.TryCreateRecordsetValue("rec1.f3.vale", "f3", "rs1", 1, out error);
            dl.TryCreateRecordsetValue("rec2.f1.vale", "f1", "rs1", 2, out error);
            dl.TryCreateRecordsetValue("rec2.f2.vale", "f2", "rs1", 2, out error);
            dl.TryCreateRecordsetValue("rec2.f3.vale", "f3", "rs1", 2, out error);

            DataListTranslatedPayloadTO tmp = xmlConverter.ConvertFrom(dl, out errors);

            string result = tmp.FetchAsString().ToString();

            Assert.AreEqual("<DataList><rs1><f1>rec1.f1.vale</f1><f2>rec1.f2.vale</f2><f3>rec1.f3.vale</f3></rs1><rs1><f1>rec2.f1.vale</f1><f2>rec2.f2.vale</f2><f3>rec2.f3.vale</f3></rs1><scalar1>scalar1Value</scalar1></DataList>", result);
        }
Esempio n. 8
0
        public void AllLower_Simple_String_Expected_All_LowerCase()
        {
            IBinaryDataListItem item   = Dev2BinaryDataListFactory.CreateBinaryItem("STRING TO MAKE LOWERCASE", "");
            IBinaryDataListItem result = converter.TryConvert("lower", item);

            Assert.AreEqual("string to make lowercase", result.TheValue);
        }
Esempio n. 9
0
        public void AllLower_StringContainingNumerics_Expected_All_LowerCase()
        {
            IBinaryDataListItem item   = Dev2BinaryDataListFactory.CreateBinaryItem("2STRING T4O M6AKE LO08WERCASE", "");
            IBinaryDataListItem result = converter.TryConvert("lower", item);

            Assert.AreEqual("2string t4o m6ake lo08wercase", result.TheValue);
        }
Esempio n. 10
0
        public void AllUpper_StringContainingNumerics_Expected_All_UpperCase()
        {
            IBinaryDataListItem item   = Dev2BinaryDataListFactory.CreateBinaryItem("2strinG 4To 8m9ake upp522erc7ase", "");
            IBinaryDataListItem result = converter.TryConvert("UPPER", item);

            Assert.AreEqual("2STRING 4TO 8M9AKE UPP522ERC7ASE", result.TheValue);
        }
Esempio n. 11
0
        public IBinaryDataList DeSerialize(string data, string targetShape, enTranslationTypes typeOf, out string error)
        {
            error = string.Empty;
            IBinaryDataList result = Dev2BinaryDataListFactory.CreateDataList();

            IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();

            if (typeOf == enTranslationTypes.XML)
            {
                ErrorResultTO errors;


                Guid resultId = compiler.ConvertTo(DataListFormat.CreateFormat(GlobalConstants._Studio_Debug_XML),
                                                   data.ToStringBuilder(),
                                                   new StringBuilder(targetShape), out errors);
                if (errors.HasErrors())
                {
                    error = errors.FetchErrors()[0]; // take the first error ;)
                }
                else
                {
                    if (result != null)
                    {
                        compiler.ForceDeleteDataListByID(result.UID);
                    }
                    result = compiler.FetchBinaryDataList(resultId, out errors);
                    if (errors.HasErrors())
                    {
                        error = errors.FetchErrors()[0]; // take the first error ;)
                    }
                }
            }

            return(result);
        }
Esempio n. 12
0
        public void TitleCase_Complex_String_Expected_All_FirstLetterUpperCaseOnAll()
        {
            IBinaryDataListItem item   = Dev2BinaryDataListFactory.CreateBinaryItem("make.(first)@ 'letter'//cap", "");
            IBinaryDataListItem result = converter.TryConvert("Title Case", item);

            Assert.AreEqual("Make.(First)@ 'Letter'//Cap", result.TheValue);
        }
Esempio n. 13
0
        public void XmlTranslator_ConvertAndFilter_WhenRecordsetWithGaps_ExpectRowAnnotations()
        {
            //------------Setup for test--------------------------
            IDataListTranslator xmlConverter = Dls.GetTranslator(XmlFormatWithoutSystemTags);
            IBinaryDataList     dl1          = Dev2BinaryDataListFactory.CreateDataList(GlobalConstants.NullDataListID);

            string error;
            var    cols = new List <Dev2Column> {
                DataListFactory.CreateDev2Column("val", string.Empty)
            };

            dl1.TryCreateRecordsetTemplate("rs", string.Empty, cols, true, out error);

            dl1.TryCreateRecordsetValue("1", "val", "rs", 1, out error);
            dl1.TryCreateRecordsetValue("3", "val", "rs", 3, out error);

            //------------Execute Test---------------------------
            ErrorResultTO errors;
            var           actual = xmlConverter.ConvertAndFilter(dl1, "<root><rs><val/></rs></root>".ToStringBuilder(), out errors);

            actual = actual.Replace("\r", "").Replace("\n", "");

            //------------Assert Results-------------------------
            const string expected = "<rs index=\"1\"><val>1</val></rs><rs index=\"3\"><val>3</val></rs>";

            StringAssert.Contains(actual.ToString(), expected, "rowID attribute not present");
        }
Esempio n. 14
0
        public void TitleCase_Simple_String_All_Caps_Expected_All_FirstLetterUpperCaseOnAll()
        {
            IBinaryDataListItem item   = Dev2BinaryDataListFactory.CreateBinaryItem("MAKE FIRST LETTER UPPERCASE", "");
            IBinaryDataListItem result = converter.TryConvert("Title Case", item);

            Assert.AreEqual("MAKE FIRST LETTER UPPERCASE", result.TheValue);
        }
Esempio n. 15
0
        public void UpperFirst_Simple_String_Expected_All_FirstLetterUpperCase()
        {
            IBinaryDataListItem item   = Dev2BinaryDataListFactory.CreateBinaryItem("make first letter uppercase", "");
            IBinaryDataListItem result = converter.TryConvert("Sentence", item);

            Assert.AreEqual("Make first letter uppercase", result.TheValue);
        }
Esempio n. 16
0
        /// <summary>
        /// Converts a list of data list item view models to a binary data list.
        /// </summary>
        /// <param name="listToConvert">The list to convert.</param>
        /// <param name="errorString">The error string.</param>
        /// <returns></returns>
        private IBinaryDataList ConvertIDataListItemModelsToIBinaryDataList(out string errorString)
        {
            errorString = string.Empty;
            IBinaryDataList result = Dev2BinaryDataListFactory.CreateDataList();

            foreach (IDataListItemModel scalar in ScalarCollection)
            {
                if (!scalar.IsBlank && !scalar.HasError)
                {
                    result.TryCreateScalarTemplate(string.Empty, scalar.Name, scalar.Description, true, scalar.IsEditable, scalar.ColumnIODirection, out errorString);
                }
            }

            foreach (IDataListItemModel recset in RecsetCollection)
            {
                if (!recset.IsBlank && !recset.HasError)
                {
                    IList <Dev2Column> cols = new List <Dev2Column>();
                    foreach (IDataListItemModel child in recset.Children.Where(c => !c.IsBlank && !c.HasError))
                    {
                        cols.Add(DataListFactory.CreateDev2Column(child.Name, child.Description, child.IsEditable, child.ColumnIODirection));
                    }

                    result.TryCreateRecordsetTemplate(recset.Name, recset.Description, cols, true, recset.IsEditable, recset.ColumnIODirection, out errorString);
                }
            }
            return(result);
        }
Esempio n. 17
0
        public IBinaryDataListItem TryConvert(string conversionType, IBinaryDataListItem item)
        {
            Func <string, string> returnedFunc;
            IBinaryDataListItem   result = Dev2BinaryDataListFactory.CreateBinaryItem("Error Invalid Conversion Type",
                                                                                      GlobalConstants.EvalautionScalar);

            if (_convertFunctions.TryGetValue(conversionType, out returnedFunc))
            {
                if (returnedFunc != null)
                {
                    string tmp = returnedFunc.Invoke(item.TheValue);
                    if (item.Namespace != string.Empty)
                    {
                        result = Dev2BinaryDataListFactory.CreateBinaryItem(tmp, item.Namespace, item.FieldName,
                                                                            item.ItemCollectionIndex);
                    }
                    else
                    {
                        result = Dev2BinaryDataListFactory.CreateBinaryItem(tmp, item.FieldName);
                    }
                }
            }

            return(result);
        }
Esempio n. 18
0
        public void TryFetchLastIndexedRecordsetUpsertPayload_ColumnName_FetchesForColumn()
        {
            //------------Setup for test--------------------------
            IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
            IDev2DataListUpsertPayloadBuilder <List <string> > toUpsert = Dev2DataListBuilderFactory.CreateStringListDataListUpsertBuilder();

            toUpsert.Add("[[rec().f1]]", new List <string> {
                "test11", "test12"
            });
            toUpsert.Add("[[rec().f2]]", new List <string> {
                "test21", "test22"
            });
            IBinaryDataList dataList = Dev2BinaryDataListFactory.CreateDataList();
            string          creationError;

            dataList.TryCreateRecordsetTemplate("rec", "recset", new List <Dev2Column> {
                DataListFactory.CreateDev2Column("f1", "f1"), DataListFactory.CreateDev2Column("f2", "f2")
            }, true, out creationError);
            ErrorResultTO localErrors;

            compiler.PushBinaryDataList(dataList.UID, dataList, out localErrors);
            compiler.Upsert(dataList.UID, toUpsert, out _errors);
            IBinaryDataListEntry recEntry;
            string error;

            dataList.TryGetEntry("rec", out recEntry, out error);
            //------------Assert Preconditions-------------------
            Assert.IsNotNull(recEntry);
            //------------Execute Test---------------------------
            var listItem = recEntry.TryFetchLastIndexedRecordsetUpsertPayload(out error, "f2");

            //------------Assert Results-------------------------
            Assert.AreEqual("test22", listItem.TheValue);
        }
Esempio n. 19
0
        public void MyTestInitialize()
        {
            string error;

            var dataListCompiler = DataListFactory.CreateDataListCompiler();

            _dl1 = Dev2BinaryDataListFactory.CreateDataList();
            _dl1.TryCreateScalarTemplate(string.Empty, "myScalar", "A scalar", true, out error);
            _dl1.TryCreateScalarValue("[[otherScalar]]", "myScalar", out error);

            _dl1.TryCreateScalarTemplate(string.Empty, "otherScalar", "A scalar", true, out error);
            _dl1.TryCreateScalarValue("testRegion", "otherScalar", out error);

            _dl1.TryCreateScalarTemplate(string.Empty, "scalar1", "A scalar", true, out error);
            _dl1.TryCreateScalarValue("foobar", "scalar1", out error);

            IList <Dev2Column> cols = new List <Dev2Column>();

            cols.Add(Dev2BinaryDataListFactory.CreateColumn("f1"));
            cols.Add(Dev2BinaryDataListFactory.CreateColumn("f2"));
            cols.Add(Dev2BinaryDataListFactory.CreateColumn("f3"));

            _dl1.TryCreateRecordsetTemplate("recset", "a recordset", cols, true, out error);

            _dl1.TryCreateRecordsetValue("r1.f1.value", "f1", "recset", 1, out error);
            _dl1.TryCreateRecordsetValue("r1.f2.value", "f2", "recset", 1, out error);
            _dl1.TryCreateRecordsetValue("r1.f3.value", "f3", "recset", 1, out error);

            _dl1.TryCreateRecordsetValue("r2.f1.value", "f1", "recset", 2, out error);
            _dl1.TryCreateRecordsetValue("r2.f2.value", "f2", "recset", 2, out error);
            _dl1.TryCreateRecordsetValue("r2.f3.value", "f3", "recset", 2, out error);

            // skip 3 ;)

            _dl1.TryCreateRecordsetValue("r4.f1.value", "f1", "recset", 4, out error);
            _dl1.TryCreateRecordsetValue("r4.f2.value", "f2", "recset", 4, out error);
            _dl1.TryCreateRecordsetValue("r4.f3.value", "f3", "recset", 4, out error);

            dataListCompiler.PushBinaryDataList(_dl1.UID, _dl1, out _errors);
            //_compiler.UpsertSystemTag(dl1.UID, enSystemTag.EvaluateIteration, "true", out errors);

            /*  list 2 */
            _dl2 = Dev2BinaryDataListFactory.CreateDataList();
            _dl2.TryCreateScalarTemplate(string.Empty, "idx", "A scalar", true, out error);
            _dl2.TryCreateScalarValue("1", "idx", out error);

            _dl2.TryCreateRecordsetTemplate("recset", "a recordset", cols, true, out error);

            _dl2.TryCreateRecordsetValue("r1.f1.value", "f1", "recset", 1, out error);
            _dl2.TryCreateRecordsetValue("r1.f2.value", "f2", "recset", 1, out error);
            _dl2.TryCreateRecordsetValue("r1.f3.value", "f3", "recset", 1, out error);

            _dl2.TryCreateRecordsetValue("r2.f1.value", "f1", "recset", 2, out error);
            _dl2.TryCreateRecordsetValue("r2.f2.value", "f2", "recset", 2, out error);
            _dl2.TryCreateRecordsetValue("r2.f3.value", "f3", "recset", 2, out error);

            dataListCompiler.PushBinaryDataList(_dl2.UID, _dl2, out _errors);
            //_compiler.UpsertSystemTag(dl2.UID, enSystemTag.EvaluateIteration, "true", out errors);
        }
Esempio n. 20
0
 static ISimulationResult CreateResult(ISimulationKey key)
 {
     return(new SimulationResult
     {
         Key = key,
         Value = Dev2BinaryDataListFactory.CreateDataList()
     });
 }
Esempio n. 21
0
        static string ExtractKeyValuePairs(NameValueCollection pairs)
        {
            IBinaryDataList bdl = Dev2BinaryDataListFactory.CreateDataList();

            // Extract request keys ;)
            foreach (var key in pairs.AllKeys)
            {
                if (key == "wid") //Don't add the Workspace ID to DataList
                {
                    continue;
                }
                if (key.IsXml())
                {
                    return(key); //We have a workspace id and XML DataList
                }
                string error;
                bdl.TryCreateScalarTemplate(string.Empty, key, string.Empty, true, out error);
                if (!string.IsNullOrEmpty(error))
                {
                    Dev2Logger.Log.Error(error);
                }

                IBinaryDataListEntry entry;
                if (bdl.TryGetEntry(key, out entry, out error))
                {
                    var item = Dev2BinaryDataListFactory.CreateBinaryItem(pairs[key], key);
                    entry.TryPutScalar(item, out error);
                    if (!string.IsNullOrEmpty(error))
                    {
                        Dev2Logger.Log.Error(error);
                    }
                }
                else
                {
                    Dev2Logger.Log.Error(error);
                }
            }

            IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
            ErrorResultTO     errors;
            Guid pushedId = compiler.PushBinaryDataList(bdl.UID, bdl, out errors);

            if (pushedId != Guid.Empty)
            {
                var result = compiler.ConvertFrom(pushedId, DataListFormat.CreateFormat(GlobalConstants._XML), enTranslationDepth.Data, out errors);
                if (errors.HasErrors())
                {
                    Dev2Logger.Log.Error(errors.MakeDisplayReady());
                }

                return(result.ToString());
            }

            Dev2Logger.Log.Error(errors.MakeDisplayReady());

            return(string.Empty);
        }
Esempio n. 22
0
        public void RecordsetGroup_Constructor_WhenDefinitionsNull_ExpectException()
        {
            //------------Setup for test--------------------------

            var entry = Dev2BinaryDataListFactory.CreateEntry(string.Empty, string.Empty, Guid.NewGuid());

            //------------Execute Test---------------------------
            var recordsetGroup = new RecordsetGroup(entry, null, definition => null, definition => null);
        }
Esempio n. 23
0
 public static void MyClassInitialize(TestContext testContext)
 {
     Directory.SetCurrentDirectory(testContext.TestDir);
     _testInstance = SimulationRepository.Instance;
     _testResult   = new SimulationResult
     {
         Key   = CreateKey(),
         Value = Dev2BinaryDataListFactory.CreateDataList()
     };
     _testInstance.Save(_testResult);
 }
Esempio n. 24
0
        public void Clone_50EntryRS_1kTimes_AtDepth()
        {
            string error;

            IBinaryDataList dl1 = Dev2BinaryDataListFactory.CreateDataList(GlobalConstants.NullDataListID);

            IList <Dev2Column> cols = new List <Dev2Column>();

            cols.Add(Dev2BinaryDataListFactory.CreateColumn("f1"));
            cols.Add(Dev2BinaryDataListFactory.CreateColumn("f2"));
            cols.Add(Dev2BinaryDataListFactory.CreateColumn("f3"));
            cols.Add(Dev2BinaryDataListFactory.CreateColumn("f4"));
            cols.Add(Dev2BinaryDataListFactory.CreateColumn("f5"));

            const int r    = 50;
            const int runs = 1000;

            dl1.TryCreateRecordsetTemplate("recset", string.Empty, cols, true, out error);


            for (int i = 0; i < r; i++)
            {
                dl1.TryCreateRecordsetValue("r1.f1.value r1.f1.value r1.f1.valuer1.f1.valuer1.f1.value", "f1", "recset", (i + 1), out error);
                dl1.TryCreateRecordsetValue("r1.f2.value", "f2", "recset", (i + 1), out error);
                dl1.TryCreateRecordsetValue("r1.f3.valuer1.f3.valuer1.f3.valuer1.f3.valuer1.f3.valuer1.f3.valuer1.f3.value", "f3", "recset", (i + 1), out error);
                dl1.TryCreateRecordsetValue("r1.f3.value", "f4", "recset", (i + 1), out error);
                dl1.TryCreateRecordsetValue("r1.f3.value r1.f3.value v r1.f3.value r1.f3.value", "f5", "recset", (i + 1), out error);
            }

            DateTime             start1 = DateTime.Now;
            string               er;
            IBinaryDataListEntry val;
            bool tryGetEntry = dl1.TryGetEntry("recset", out val, out er);

            for (int q = 0; q < runs; q++)
            {
                if (tryGetEntry)
                {
                    val.Clone(enTranslationDepth.Data, dl1.UID, out er);
                }
            }


            DateTime end1 = DateTime.Now;

            long   ticks   = (end1.Ticks - start1.Ticks);
            double result1 = (ticks / _ticksPerSec);

            Console.WriteLine(result1 + @" seconds for " + runs + @" to clone ");

            Assert.IsTrue(result1 <= 10.5); // Given .01 buffer ;) WAS : 0.065
        }
Esempio n. 25
0
        public void CanIterateNormally()
        {
            const int      maxValue = 5;
            IIndexIterator ii       = Dev2BinaryDataListFactory.CreateLoopedIndexIterator(10, maxValue);
            int            cnt      = 0;

            while (ii.HasMore())
            {
                ii.FetchNextIndex();
                cnt++;
            }

            Assert.AreEqual(maxValue, cnt);
        }
Esempio n. 26
0
        /// <summary>
        /// Gets the wizard data list for a workflow.
        /// </summary>
        /// <param name="dataList"></param>
        /// <returns>
        /// The string for the data list
        /// </returns>
        /// <exception cref="System.Exception">
        /// </exception>
        public string GetWizardDataListForWorkflow(string dataList)
        {
            IBinaryDataList newDl = Dev2BinaryDataListFactory.CreateDataList();
            ErrorResultTO   errors;
            var             dataListStringBuilder = new StringBuilder(dataList);
            Guid            dlID = ConvertTo(DataListFormat.CreateFormat(GlobalConstants._XML_Without_SystemTags), dataListStringBuilder, dataListStringBuilder, out errors);

            if (!errors.HasErrors())
            {
                IBinaryDataList dl = FetchBinaryDataList(dlID, out errors);
                if (!errors.HasErrors())
                {
                    IList <IBinaryDataListEntry> entries = dl.FetchAllEntries();
                    foreach (IBinaryDataListEntry entry in entries)
                    {
                        if (entry.IsRecordset)
                        {
                            if (entry.ColumnIODirection != enDev2ColumnArgumentDirection.None)
                            {
                                string tmpError;
                                newDl.TryCreateRecordsetTemplate(entry.Namespace, entry.Description, entry.Columns, true, out tmpError);
                            }
                        }
                        else
                        {
                            if (entry.ColumnIODirection != enDev2ColumnArgumentDirection.None)
                            {
                                string tmpError;
                                IBinaryDataListItem scalar = entry.FetchScalar();
                                newDl.TryCreateScalarTemplate(string.Empty, scalar.FieldName, entry.Description, true, out tmpError);
                            }
                        }
                    }
                    Guid newDlId = PushBinaryDataList(newDl.UID, newDl, out errors);
                    dataList = ConvertFrom(newDlId, DataListFormat.CreateFormat(GlobalConstants._XML_Without_SystemTags), enTranslationDepth.Shape, out errors).ToString();
                }
                else
                {
                    throw new Exception(errors.MakeUserReady());
                }
            }
            else
            {
                throw new Exception(errors.MakeUserReady());
            }
            return(dataList);
        }
Esempio n. 27
0
        public void DeserializeToXMLFromBinaryDataListWhereDataListContainsInvalidXMLCharactersExpectedInvalidCharactersAreEscaped()
        {
            IDataListTranslator xmlConverter = Dls.GetTranslator(XmlFormat);
            IBinaryDataList     dl1          = Dev2BinaryDataListFactory.CreateDataList(GlobalConstants.NullDataListID);

            string error;

            dl1.TryCreateScalarTemplate(string.Empty, "cake", "", false, true, enDev2ColumnArgumentDirection.Both, out error);
            dl1.TryCreateScalarValue("Travis Is \"Cool\"&>'nstuff'<", "cake", out error);

            ErrorResultTO errors;
            var           payload = xmlConverter.ConvertFrom(dl1, out errors);

            string       actual   = payload.FetchAsString().ToString();
            const string expected = "Travis Is \"Cool\"&amp;>'nstuff'<";

            StringAssert.Contains(actual, expected, "Not all XML special characters are escaped i.e \"'><&");
        }
        public void BaseConvertRecsetWithStarIndexToBinaryExpectedOutputToCorrectRecords()
        {
            SetupArguments(
                @"<root></root>"
                , ActivityStrings.BaseConvert_DLShape.Replace("<ADL>", "<ADL><setup/>")
                , new List <BaseConvertTO> {
                new BaseConvertTO("", "Text", "Binary", "[[setup]]", 1)
            }
                );
            IDSFDataObject  result = ExecuteProcess();
            ErrorResultTO   errorResult;
            IBinaryDataList bdl = Compiler.FetchBinaryDataList(result.DataListID, out errorResult);

            IBinaryDataListItem isolatedRecord = Dev2BinaryDataListFactory.CreateBinaryItem("CONVERT THIS TO BINARY", "Field");
            string error;
            IBinaryDataListEntry entry;

            bdl.TryGetEntry("Recset", out entry, out error);
            entry.TryPutRecordItemAtIndex(isolatedRecord, 5, out error);

            IList <BaseConvertTO> convertCollection = new List <BaseConvertTO> {
                new BaseConvertTO("[[Recset(*).Field]]", "Text", "Binary", "[[Recset(*).Field]]", 1)
            };

            TestStartNode = new FlowStep
            {
                Action = new DsfBaseConvertActivity {
                    ConvertCollection = convertCollection
                }
            };
            result = ExecuteProcess();

            IList <IBinaryDataListEntry> actual = bdl.FetchRecordsetEntries();
            var index       = actual[0].FetchRecordAt(5, out error)[0].ItemCollectionIndex;
            var count       = actual.Count();
            var actualValue = actual[0].FetchRecordAt(5, out error)[0].TheValue;

            // remove test datalist ;)
            DataListRemoval(result.DataListID);

            Assert.AreEqual("01000011010011110100111001010110010001010101001001010100001000000101010001001000010010010101001100100000010101000100111100100000010000100100100101001110010000010101001001011001", actualValue);
            Assert.AreEqual(1, count); // still only one record
            Assert.AreEqual(5, index); // and that record has not moved
        }
Esempio n. 29
0
        public void UpsertWhereListStringExpectUpsertCorrectlyMultipleRecordset()
        {
            //------------Setup for test--------------------------
            IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
            IDev2DataListUpsertPayloadBuilder <List <string> > toUpsert = Dev2DataListBuilderFactory.CreateStringListDataListUpsertBuilder();

            toUpsert.Add("[[rec().f1]]", new List <string> {
                "test11", "test12"
            });
            toUpsert.Add("[[rec().f2]]", new List <string> {
                "test21", "test22"
            });
            IBinaryDataList dataList = Dev2BinaryDataListFactory.CreateDataList();
            string          creationError;

            dataList.TryCreateRecordsetTemplate("rec", "recset", new List <Dev2Column> {
                DataListFactory.CreateDev2Column("f1", "f1"), DataListFactory.CreateDev2Column("f2", "f2")
            }, true, out creationError);
            ErrorResultTO localErrors;

            compiler.PushBinaryDataList(dataList.UID, dataList, out localErrors);
            //------------Execute Test---------------------------
            compiler.Upsert(dataList.UID, toUpsert, out _errors);
            //------------Assert Results-------------------------
            IList <IBinaryDataListEntry> binaryDataListEntries = dataList.FetchRecordsetEntries();
            IBinaryDataListEntry         binaryDataListEntry   = binaryDataListEntries[0];
            string errString;
            IList <IBinaryDataListItem> binaryDataListItems = binaryDataListEntry.FetchRecordAt(1, out errString);
            IBinaryDataListItem         binaryDataListItem  = binaryDataListItems[0];
            IBinaryDataListItem         binaryDataListItem2 = binaryDataListItems[1];
            string theValue = binaryDataListItem.TheValue;

            Assert.AreEqual("test11", theValue);
            theValue = binaryDataListItem2.TheValue;
            Assert.AreEqual("test21", theValue);
            binaryDataListItems = binaryDataListEntry.FetchRecordAt(2, out errString);
            binaryDataListItem  = binaryDataListItems[0];
            binaryDataListItem2 = binaryDataListItems[1];
            theValue            = binaryDataListItem.TheValue;
            Assert.AreEqual("test12", theValue);
            theValue = binaryDataListItem2.TheValue;

            Assert.AreEqual("test22", theValue);
        }
Esempio n. 30
0
        /// <summary>
        /// Gets the outputs.
        /// </summary>
        /// <param name="obj">The obj to get outputs for.</param>
        /// <returns></returns>
        public static IBinaryDataList GetSimpleOutputs(object obj)
        {
            IBinaryDataList binaryDL   = Dev2BinaryDataListFactory.CreateDataList();
            Type            sourceType = obj.GetType();

            foreach (PropertyInfo pi in sourceType.GetProperties())
            {
                List <Outputs> listOfInputs = pi.GetCustomAttributes(typeof(Outputs), true).OfType <Outputs>().ToList();
                if (listOfInputs.Count > 0)
                {
                    string error;
                    if (binaryDL.TryCreateScalarTemplate(string.Empty, listOfInputs[0].UserVisibleName, "", true, out error))
                    {
                        binaryDL.TryCreateScalarValue(pi.GetValue(obj, null).ToString(), listOfInputs[0].UserVisibleName, out error);
                    }
                }
            }
            return(binaryDL);
        }