public void Convert_IEnumerableOfString_IsSupported()
 {
     var converter = new SimpleDbConverter();
     var theList = new List<string>();
     var forSimpleDb = converter.ConvertToSimpleDb(theList.GetType(), theList);
     Assert.AreEqual(string.Empty, forSimpleDb);
     theList.Add("blue");
     theList.Add("red");
     theList.Add("green");
     forSimpleDb = converter.ConvertToSimpleDb(theList.GetType(), theList);
     Assert.AreEqual("blue,red,green", forSimpleDb);
     var toSimpleDb = converter.ConvertFromSimpleDb(theList.GetType(), forSimpleDb);
     Assert.AreEqual(toSimpleDb, theList);
 }
        public void Can_convert_shippingOptionList_to_string_and_back()
        {
            var shippingOptionsInput = new List<ShippingOption>();
            shippingOptionsInput.Add(new ShippingOption()
            {
                Name = "a1",
                Description = "a2",
                Rate = 3.57M,
                ShippingRateComputationMethodSystemName = "a4"
            });
            shippingOptionsInput.Add(new ShippingOption()
            {
                Name = "b1",
                Description = "b2",
                Rate = 7.00M,
                ShippingRateComputationMethodSystemName = "b4"
            });

			var converter = CommonHelper.GetTypeConverter(shippingOptionsInput.GetType());
            var result = converter.ConvertTo(shippingOptionsInput, typeof(string)) as string;

            var shippingOptionsOutput = converter.ConvertFrom(result) as List<ShippingOption>;
            shippingOptionsOutput.ShouldNotBeNull();
            shippingOptionsOutput.Count.ShouldEqual(2);
            shippingOptionsOutput[0].Name.ShouldEqual("a1");
            shippingOptionsOutput[0].Description.ShouldEqual("a2");
            shippingOptionsOutput[0].Rate.ShouldEqual(3.57M);
            shippingOptionsOutput[0].ShippingRateComputationMethodSystemName.ShouldEqual("a4");

            shippingOptionsOutput[1].Name.ShouldEqual("b1");
            shippingOptionsOutput[1].Description.ShouldEqual("b2");
            shippingOptionsOutput[1].Rate.ShouldEqual(7.00M);
            shippingOptionsOutput[1].ShippingRateComputationMethodSystemName.ShouldEqual("b4");
        }
        public void CanWrite_ReturnsFalse_IfValueIsAList()
        {
            object value = new ArrayList();
            Assert.IsFalse(writer.CanWrite(value, value.GetType()));

            value = new List<int>();
            Assert.IsFalse(writer.CanWrite(value, value.GetType()));
        }
 public void Can_convert_string_list_to_string()
 {
     var items = new List<string> { "foo", "bar", "day" };
     var converter = TypeDescriptor.GetConverter(items.GetType());
     var result = converter.ConvertTo(items, typeof(string)) as string;
     result.ShouldNotBeNull();
     result.ShouldEqual("foo,bar,day");
 }
        public void Can_convert_int_list_to_string()
        {
            var items = new List<int> { 10, 20, 30, 40, 50 };
            var converter = TypeDescriptor.GetConverter(items.GetType());
            var result = converter.ConvertTo(items, typeof(string)) as string;

            result.ShouldNotBeNull();
            result.ShouldEqual("10,20,30,40,50");
        }
Пример #6
0
        public void DoCheck()
        {
            var loGenericItem = new List<List<String>>();
            var loTypeAnatomy = loGenericItem.GetType().GetTypeAnatomy();

            Assert.IsNotNull(loTypeAnatomy);

            var loGenericItemFromAnatomy = loTypeAnatomy.CreateInstance();

            Assert.IsTrue(loGenericItemFromAnatomy is List<List<String>>);
        }
Пример #7
0
        public void NonPrimitiveInstanceTest()
        {
            List<String> testList = new List<String>();
            Type listType = testList.GetType();

            var creationData = new ObjectCreationData(listType.GetConstructor(Type.EmptyTypes));

            var objInstance = new ObjectInstance(testList, creationData);
            Assert.That(objInstance.Instance, Is.SameAs(testList));
            Assert.That(objInstance.InstanceNeedsConstructor, Is.True);
            Assert.That(objInstance.CreationData, Is.SameAs(creationData));
        }
Пример #8
0
 public void ShouldAssignArrayOfListsToNative()
 {
     var intArray = new int[1][];
     intArray[0] = new int[1] { 2 };
     List<int>[] listArray = new List<int> [1] { new List<int> { 1 } };
     SinTDArray innerArray = new SinTDArray();
     innerArray.elementType = SinTDInstance.GetSinTDType("i32");
     SinTDArray outerArray = new SinTDArray();
     outerArray.elementType = innerArray;
     List<int>[] test = (List<int>[])outerArray.AssignValuesToNativeType(intArray, listArray.GetType());
     Assert.IsAssignableFrom<List<int>>(test[0]);
     Assert.AreEqual(2, test[0][0]);
 }
        public void SholdKnowIfATypeIsAListOfResources()
        {
            var list = new List<IBehaveAsResource>();
            var array = new[] {new SomeResource()};

            var notAResourceList = new List<int>();
            var notAResourceArray = new[] {1, 2};

            Assert.IsTrue(list.GetType().IsAListOfResources());
            Assert.IsTrue(array.GetType().IsAListOfResources());

            Assert.IsFalse(notAResourceList.GetType().IsAListOfResources());
            Assert.IsFalse(notAResourceArray.GetType().IsAListOfResources());
        }
Пример #10
0
        public static void ComplexCollection()
        {
            var items = new List<object>();
            items.Add(5);
            items.Add("hello");
            items.Add(new { number = 3 });
            items.Add(new Dictionary<string, object>() { { "file", "hello.jpg" } });
            var serialized = Json.Serialize(items);

            var deserializedItems = Json.Deserialize(serialized, items.GetType()) as List<object>;
            Assert.AreEqual(deserializedItems.Count, 4);
            Assert.AreEqual(deserializedItems[0], 5);
            Assert.AreEqual(deserializedItems[1], "hello");
            Assert.AreEqual(((IDictionary)deserializedItems[2])["number"], 3);
            Assert.AreEqual(((IDictionary)deserializedItems[3])["file"], "hello.jpg");
        }
Пример #11
0
        public void Cast()
        {
            object source = new List<M1> {new M1 {Name = "o"}};
            object target = new List<M2>();

            var targetArgumentType = target.GetType().GetGenericArguments()[0];

            var list = Activator.CreateInstance(typeof(List<>).MakeGenericType(targetArgumentType));
            var add = list.GetType().GetMethod("Add");

            foreach (var o in source as IEnumerable)
            {
                var t = Activator.CreateInstance(targetArgumentType);
                add.Invoke(list, new[] { t.InjectFrom(o) });
            }

            target = list;

            Assert.AreEqual("o", (target as List<M2>).First().Name);
        }
Пример #12
0
        public void TestGenericArguments()
        {
            IList<string> strlist = new List<string>();

            Type type = strlist.GetType();
            Assert.IsTrue(type.IsGenericType);

            Assert.AreEqual(typeof(string),type.GetGenericArguments()[0]);
        }
Пример #13
0
        public void SerializeDeserailize_listOfSerializableGetSetPropertiesOfPrimitiveType_theSame()
        {
            GetSetProperties o = new GetSetProperties { dat = "fff"};
            var l = new List<GetSetProperties>();
            l.Add(o);
            l.Add(o);
            var ser = new XmlSerializer(l.GetType());
            var nss = new XmlSerializerNamespaces();
            nss.Add(String.Empty, String.Empty);
            var m = new MemoryStream();

            ser.Serialize(m,l, nss);
            m.Position = 0;
            var de = (List<GetSetProperties>)ser.Deserialize(m);

            Assert.AreEqual(o.dat, de[0].dat);
            Assert.AreEqual(o.dat, de[1].dat);
        }
Пример #14
0
            public void ReturnsFalseForNonDerivingClass()
            {
                var genericType = typeof (SavableModelBase<>);
                var toCheck = new List<string>();

                Assert.IsFalse(TypeHelper.IsSubclassOfRawGeneric(genericType, toCheck.GetType()));
            }
Пример #15
0
        public void PolymorphicSerializationThroughListWhichMayContainYaxlibNamespaceTest()
        {
            var lst = new List<object> { 1, 2, 3 };
            var ser = new YAXSerializer(typeof(object));
            string xmlResult = ser.Serialize(lst);

            const string expectedResult =
            @"<Object xmlns:yaxlib=""http://www.sinairv.com/yaxlib/"" yaxlib:realtype=""System.Collections.Generic.List`1[[System.Object, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]"">
              <Int32 yaxlib:realtype=""System.Int32"">1</Int32>
              <Int32 yaxlib:realtype=""System.Int32"">2</Int32>
              <Int32 yaxlib:realtype=""System.Int32"">3</Int32>
            </Object>";

            Assert.That(xmlResult.StripTypeAssemblyVersion(), Is.EqualTo(expectedResult.StripTypeAssemblyVersion()));
            var desObj = ser.Deserialize(xmlResult);
            Assert.That(desObj.GetType(), Is.EqualTo(lst.GetType()));
            var desLst = desObj as List<object>;
            Assert.That(lst, Has.Count.EqualTo(desLst.Count));
            Assert.That(lst, Is.EquivalentTo(desLst));
        }
Пример #16
0
            public void ReturnsTrueForDerivingClass()
            {
                var genericType = typeof (List<>);
                var toCheck = new List<string>();

                Assert.IsTrue(TypeHelper.IsSubclassOfRawGeneric(genericType, toCheck.GetType()));
            }
            public static IEnumerable<TestCaseData> TestCases2()
            {
                var r = new Random();
                yield return new TestCaseData(r.Next(),typeof(int));
                yield return new TestCaseData(Math.Round(r.NextDouble(), 15), typeof(double));
                yield return new TestCaseData("test string",typeof(string));
                yield return new TestCaseData(DateTime.UtcNow,typeof(DateTime));

                var len = r.Next(5, 30);
                var array = Enumerable.Repeat(0, len).Select(a => r.Next()).ToArray();
                yield return new TestCaseData(array,typeof(int[]));

                var list = new List<int>(array);
                yield return new TestCaseData(list,list.GetType());

                var list2 = new ArrayList(array);
                yield return new TestCaseData(list2,list2.GetType());

                var hashset = new HashSet<double>();
                hashset.UnionWith(Enumerable.Repeat(0,r.Next(5,50)).Select(a => Math.Round(r.NextDouble(), 15)));

                yield return new TestCaseData(hashset,typeof(HashSet<double>));

                var hashset2 = new HashSet<string>(StringComparer.InvariantCultureIgnoreCase);
                hashset2.UnionWith(Enumerable.Repeat(0,r.Next(5,30)).Select(i => RandomString(r.Next(5,10))));
                yield return new TestCaseData(hashset2,typeof(HashSet<string>));

                var dic = new Dictionary<string,int>();
                var entries = r.Next(3, 10);
                for (int i = 0; i < entries; i++)
                {
                    string key;
                    do
                    {
                        key = RandomString(6);
                    } while (dic.ContainsKey(key));
                    dic.Add(key,r.Next());
                }
                yield return new TestCaseData(dic,typeof(Dictionary<string, int>));

                var dic2 = new Dictionary<string,int>(StringComparer.InvariantCultureIgnoreCase);
                var entries2 = r.Next(3, 10);
                for (int i = 0; i < entries2; i++)
                {
                    string key;
                    do
                    {
                        key = RandomString(6);
                    } while (dic2.ContainsKey(key));
                    dic2.Add(key, r.Next());
                }
                yield return new TestCaseData(dic2, typeof(Dictionary<string, int>));
            }
Пример #18
0
 public void ShouldAssignListOfArraysToNative()
 {
     var intArray = new int[1][];
     intArray[0] = new int[1] { 2 };
     List<int[]> arrayList = new List<int[]>{ new int[1] { 1 } };
     SinTDArray innerArray = new SinTDArray();
     innerArray.elementType = SinTDInstance.GetSinTDType("i32");
     SinTDArray outerArray = new SinTDArray();
     outerArray.elementType = innerArray;
     List<int[]> test = (List<int[]>)outerArray.AssignValuesToNativeType(intArray, arrayList.GetType());
     Assert.IsAssignableFrom<int[]>(test[0]);
     Assert.AreEqual(2, test[0][0]);
 }
Пример #19
0
 public void ShouldAssignArrayToNativeList()
 {
     var intList = new List<int>();
     SinTDArray array = new SinTDArray();
     array.elementType = SinTDInstance.GetSinTDType("i32");
     List<int> test = (List<int>)array.AssignValuesToNativeType(new int[1] { 1 }, intList.GetType());
     Assert.AreEqual(1, test.Count);
     Assert.AreEqual(1, test[0]);
 }
 public void IsEnumerable()
 {
     var enumerable = new List<int> { 3, 5, 7, 8, 9}.Where(i => i > 4);
     var type = enumerable.GetType();
     Assert.That(TypeHelper.IsEnumerable(type));
 }
Пример #21
0
        /// <summary>
        /// тесты для функции сервиса GetRelativesList
        /// </summary>
        public static void TestGetRelativesList()
        {
            //настройка сериализации типа DateTime в JSON
            JsonSerializerSettings settings = new JsonSerializerSettings();
            settings.DateFormatHandling = DateFormatHandling.MicrosoftDateFormat;
            //адресс функции сервиса
            string operationUrl = "http://localhost:8732/Design_Time_Addresses/RESTService/GetRelativesList";
            //параметры для функции
            string passportNumber = "1111654321";
            Person filter = new Person { Address = "", 
                                         DateOfBirth = new DateTime(), 
                                         FirstName = "Igor", 
                                         PassportNumber = "", 
                                         PersonID = 0, 
                                         SecondName = "", 
                                         Sex = "", 
                                         ThirdName = "" };

            //создание и отправка запроса сервису
            #region Send Request
            //описание Url запроса
            WebRequest req = WebRequest.Create(operationUrl + "?passportNumber=" + passportNumber);
            //описание метода запрса
            req.Method = "POST";
            req.Timeout = 12000;
            //описание формата обмена данными
            req.ContentType = "application/" + dataFormat;
            //конвертация параметров из С# в соответствующий формат
            #region Create params
            string filterStr = "";
            if (dataFormat == "json")
            {
                filterStr = "{\"filter\":"+ JsonConvert.SerializeObject(filter, settings) + "}";
            }
            else
            {
                filterStr = "<GetRelativesList>" + 
                            "<filter xmlns:a=\"http://Person\">" +
                            "<a:Address>" + filter.Address + "</a:Address>" +
                            "<a:DateOfBirth>" + filter.DateOfBirth.Value.ToString("o") + "</a:DateOfBirth>" +
                            "<a:FirstName>" + filter.FirstName + "</a:FirstName>" +
                            "<a:PassportNumber>" + filter.PassportNumber + "</a:PassportNumber>" +
                            "<a:PersonID>" + filter.PersonID + "</a:PersonID>" +
                            "<a:SecondName>" + filter.SecondName + "</a:SecondName>" +
                            "<a:Sex>" + filter.Sex + "</a:Sex>" +
                            "<a:ThirdName>" + filter.ThirdName + "</a:ThirdName>" +
                            "</filter>" +
                            "</GetRelativesList>";

                /*StringBuilder sb = new StringBuilder();
                StringWriter sw = new StringWriter(sb);
                XmlDocument doc = new XmlDocument();
                XmlElement operationEl = doc.CreateElement("GetRelativesList");
                XmlElement filterEl = doc.CreateElement("filter");
                filterEl.SetAttribute("xmlns:a", "http://Person");
                XmlElement AddresseEl = doc.CreateElement("a", "Addresse", "http://Person");
                AddresseEl.InnerText = filter.Addresse;
                XmlElement dobEl = doc.CreateElement("DateOfBirth");
                dobEl.InnerText = filter.DateOfBirth.ToUniversalTime().ToString();
                XmlElement firstNameEl = doc.CreateElement("a", "FirstName", "http://Person");
                firstNameEl.InnerText = filter.FirstName;
                XmlElement pasportNumberEl = doc.CreateElement("PasportNumber");
                pasportNumberEl.InnerText = filter.PasportNumber;
                XmlElement personIDEl = doc.CreateElement("PersonID");
                personIDEl.InnerText = filter.PersonID.ToString();
                XmlElement secondNameEl = doc.CreateElement("SecondName");
                secondNameEl.InnerText = filter.SecondName;
                XmlElement sexEl = doc.CreateElement("Sex");
                sexEl.InnerText = filter.Sex;
                XmlElement thirdNameEl = doc.CreateElement("ThirdName");
                thirdNameEl.InnerText = filter.ThirdName;
                filterEl.AppendChild(AddresseEl);
                filterEl.AppendChild(dobEl);
                filterEl.AppendChild(firstNameEl);
                filterEl.AppendChild(pasportNumberEl);
                filterEl.AppendChild(personIDEl);
                filterEl.AppendChild(secondNameEl);
                filterEl.AppendChild(sexEl);
                filterEl.AppendChild(thirdNameEl);
                operationEl.AppendChild(filterEl);
                XmlTextWriter xtw = new XmlTextWriter(sw);
                doc.AppendChild(operationEl);
                doc.WriteContentTo(xtw);
                xtw.Close();
                filterStr = sb.ToString();*/
            }
            Console.WriteLine(filterStr);
            #endregion
            byte[] data = Encoding.GetEncoding(1251).GetBytes(filterStr);
            req.ContentLength = data.Length;
            Stream sendStream = req.GetRequestStream();
            sendStream.Write(data, 0, data.Length);
            sendStream.Close();
            #endregion
            //получение и обработка ответа сервиса
            #region Get Response
            WebResponse resp = req.GetResponse();
            System.IO.Stream stream = resp.GetResponseStream();
            StreamReader sr = new System.IO.StreamReader(stream);
            List<Relative> result = new List<Relative>();
            //конвертация строки ответа в объект C# типа List<Relative>
            if (dataFormat == "json")
            {
                string s = sr.ReadToEnd();
                Console.WriteLine(s);
                result = JsonConvert.DeserializeObject<List<Relative>>(s, settings);
            }
            else
            {
                string s = sr.ReadToEnd();
                Console.WriteLine(s);
                StringReader strR = new StringReader(s);

                string root = "ArrayOfRelative";
                XmlRootAttribute xra = new XmlRootAttribute();
                xra.ElementName = root;
                xra.Namespace = "http://schemas.datacontract.org/2004/07/DomainModel.Entities";
                result = (List<Relative>)(new XmlSerializer(result.GetType(), xra).Deserialize(strR));
            }
            #endregion

            Assert.IsTrue(result.Count == 1);
            Assert.IsTrue(result.First().RelationshipState == "father");
        }
 public void Convert_UnsupportedType_ThrowsArgumentOutOfRangeException()
 {
     var converter = new SimpleDbConverter();
     var unsupportedType = new List<int>();
     converter.ConvertToSimpleDb(unsupportedType.GetType(), unsupportedType);
 }
 public void VerifyTypeImplementsGenericInterfaceIEnumerator()
 {
     List<Int32> obj = new List<int>();
     Type type = obj.GetType();
     Assert.That(type.ImplementsInterface(typeof(IEnumerable)), Is.True);
 }