Esempio n. 1
0
        public void Can_Get_Property_Attribute()
        {
            var sample      = new Sample1();
            var sampelTypes = typeof(Sample1).GetProperties().SelectMany(
                x => x.GetCustomAttributes(typeof(LookupAttribute), false));

            Assert.Equal(1, sampelTypes.Count());
            var ctype      = sampelTypes.First();
            var lookuptype = ((LookupAttribute)ctype).LookupType;



            var result = typeof(LookupAttribute).Assembly.GetTypes()
                         .Where(t => t.BaseType != null && t.BaseType.IsGenericType &&
                                t.BaseType.GetGenericTypeDefinition() == typeof(Repository <,>) &&
                                t.BaseType.GetGenericArguments()[0].FullName == lookuptype.FullName).FirstOrDefault();

            dynamic          repository = Activator.CreateInstance(result);
            List <Car1Model> cc         = repository.GetList();

            Assert.Equal(cc.Count, 2);



            //dynamic repository = Activator.CreateInstance(lookuptype);
            //List<Car1Model> cc = repository.GetList();
            //List < Car1Model > cc= repository.GetList();
            //Assert.Equal(cc.Count, 2);
            //.Where(x => x.GetCustomAttributes(typeof(LookupAttribute), false).Length > 0);

            // var attr = (LookupAttribute[])pi.GetCustomAttributes(typeof(LookupAttribute), false);


            //var list=(LookupAttribute)sampelType.First()
        }
Esempio n. 2
0
        public void TestBasicTypesEqualityInner()
        {
            Sample1 obj1 = new Sample1();
            Sample1 obj2 = new Sample1();

            EqualityHelper helper = new EqualityHelper(obj1);

            helper.Add((Sample1 x) => x.IntProp);
            helper.Add((Sample1 x) => x.StringProp);

            helper.ObjectEquals(obj2).Should().Be.True();

            obj1.IntProp = obj2.IntProp = 42;
            helper.ObjectEquals(obj2).Should().Be.True();
            helper.ObjectGetHashCode(obj2).Should().Be(helper.ObjectGetHashCode());

            obj1.StringProp = "A";
            helper.ObjectEquals(obj2).Should().Be.False();

            obj2.StringProp = "B";
            helper.ObjectEquals(obj2).Should().Be.False();

            obj1.StringProp = "B";
            helper.ObjectEquals(obj2).Should().Be.True();
            helper.ObjectGetHashCode(obj2).Should().Be(helper.ObjectGetHashCode());
        }
Esempio n. 3
0
        public void ShouldServeAsNonGenericIEqualityComparer()
        {
            Sample1 obj1 = new Sample1();

            EqualityHelper <Sample1> helper = new EqualityHelper <Sample1>();

            helper.Add(x => x.IntProp);
            helper.Add(x => x.StringProp);

            var hash = new Hashtable(helper);

            hash.Add(new Sample1()
            {
                IntProp = 2, StringProp = "asd"
            }, "doesn't matter");

            hash.ContainsKey(new Sample1()
            {
                IntProp = 2, StringProp = "asd"
            }).Should().Be.True();
            hash.ContainsKey(new Sample1()
            {
                IntProp = 3, StringProp = "asd"
            }).Should().Be.False();
        }
Esempio n. 4
0
        private bool getSampleRatios()
        {
            bool check = true;

            if (StrataField == "")
            {
                int numberSamples1 = Sample1.RowCount(null);
                int numberSamples2 = Sample2.RowCount(null);
                cntDic.Add("1", new int[] { numberSamples1, numberSamples2 });
            }
            else
            {
                Dictionary <string, int> s1DicCnt = getUniqueValueCounts(Sample1);
                Dictionary <string, int> s2DicCnt = getUniqueValueCounts(Sample2);
                foreach (string s in s1DicCnt.Keys)
                {
                    if (!s2DicCnt.Keys.Contains(s))
                    {
                        check = false;
                        return(check);
                    }
                    else
                    {
                        int s1Cnt = s1DicCnt[s];
                        int s2Cnt = s2DicCnt[s];
                        cntDic.Add(s, new int[] { s1Cnt, s2Cnt });
                    }
                }
            }
            return(check);
        }
Esempio n. 5
0
        public void TestInheritanceOuter()
        {
            Sample1 obj1 = new Sample1();
            Sample2 obj2 = new Sample2();

            EqualityHelper helper = new EqualityHelper(typeof(Sample1));

            helper.AddAllProperties();

            helper.ObjectEquals(obj1, obj2).Should().Be.True();

            obj1.IntProp = obj2.IntProp = 42;
            helper.ObjectEquals(obj1, obj2).Should().Be.True();
            helper.ObjectGetHashCode(obj2).Should().Be(helper.ObjectGetHashCode(obj1));

            obj1.StringProp = "A";
            helper.ObjectEquals(obj1, obj2).Should().Be.False();

            obj2.StringProp = "B";
            helper.ObjectEquals(obj1, obj2).Should().Be.False();

            obj1.StringProp = "B";
            helper.ObjectEquals(obj1, obj2).Should().Be.True();
            helper.ObjectGetHashCode(obj2).Should().Be(helper.ObjectGetHashCode(obj1));
        }
Esempio n. 6
0
        static void Main(string[] args)
        {
            Sample1.DateTimeSample();

            //Sample2.SampleTester();

            //Sample3.TimerCallbackSample();
        }
Esempio n. 7
0
        static void Main(string[] args)
        {
            Sample1 app = new Sample1();

            while (true)
            {
            }
        }
Esempio n. 8
0
    static void Main()
    {
        Sample1 S1 = new Sample1();
        Sample2 S2 = new Sample2();

        S1.Method();
        S2.Method();
    }
Esempio n. 9
0
        public static void Main()
        {
            Sample1 del1 = new Sample1(SampleMethod1);

            del1 += SampleMethod2;      //invokes both samplemethod1 and samplemethod2

            del1();
        }
Esempio n. 10
0
        private void Button_Click_3(object sender, RoutedEventArgs e)
        {
            Sample1.InitAxisX();
            Sample1.InitAxisY();

            Sample2.InitAxisX();
            Sample2.InitAxisY();
        }
Esempio n. 11
0
        public void InvokeTest()
        {
            var sample1 = new Sample1();

            Assert.AreEqual("A1000", sample1.Invoke("Method1", "A", 1000));
            AssertEx.AreThrow(new InvalidDataException(), () => sample1.Invoke("method2", "B", 2000));
            AssertEx.AreThrow(new InvalidDataException(), () => sample1.Invoke("method1", 2000));
        }
        public void CanCompareEqualInstances()
        {
            var obj1 = new Sample1() { IntProp = 1, StringProp = "2", IgnoreProp = DateTime.Now };
            var obj2 = new Sample1() { IntProp = 1, StringProp = "2", IgnoreProp = DateTime.Now.AddDays(1) };

            obj2.Should().Be(obj1);
            obj2.GetHashCode().Should().Be(obj1.GetHashCode());
        }
        public void Deserialize1()
        {
            JObject obj = new JObject();

            Sample1 value = obj.ToObject <Sample1>();

            Assert.IsNull(value.Query);
        }
Esempio n. 14
0
        public ActionResult DeleteConfirmed(int id)
        {
            Sample1 sample1 = db.Sample1.Find(id);

            db.Sample1.Remove(sample1);
            db.SaveChanges();
            return(RedirectToAction("Index"));
        }
Esempio n. 15
0
        public void GetParametersTypeTest()
        {
            var sample1 = new Sample1();

            Assert.AreEqual(typeof(string), sample1.GetParametersType("Method1", 0));
            Assert.AreEqual(typeof(int), sample1.GetParametersType("Method1", 1));
            AssertEx.AreThrow(new InvalidDataException(), () => sample1.GetParametersType("Method2", 1));
            AssertEx.AreThrow(new IndexOutOfRangeException(), () => sample1.GetParametersType("Method1", 3));
        }
Esempio n. 16
0
        public FileStreamResult GetSample1()
        {
            var pdf = Sample1.GetSample(null);

            pdf.Buffer.BaseStream.Seek(0, SeekOrigin.Begin);
            var result = new FileStreamResult(pdf.Buffer.BaseStream, "application/pdf");

            return(result);
        }
Esempio n. 17
0
        public void TestDifferentTypes()
        {
            Sample1 obj1 = new Sample1();
            int     obj2 = 42;

            EqualityHelper helper = new EqualityHelper(typeof(Sample1));

            helper.ObjectEquals(obj1, obj2).Should().Be.False();
        }
Esempio n. 18
0
 public void TestSerializeToString()
 {
     var value = new Sample1()
     {
         Prop1 = 2, Prop2 = "333"
     };
     var data  = GetSerializer <Sample1>().Serialize(value);
     var data2 = GetStringSerializer <Sample1>().SerializeToString(value);
 }
Esempio n. 19
0
        public MainWindow()
        {
            InitializeComponent();

            this.DataContext = this;

            Sample1.Init();
            Sample2.Init(plot, x, y, series);
        }
Esempio n. 20
0
        public void TestToStringSingleKey()
        {
            var obj1   = new Sample1();
            var helper = new EqualityHelper <Sample1>(x => x.IntProp);

            obj1.IntProp = 123;

            helper.ObjectToString(obj1).Should().Be("(IntProp=123)");
        }
Esempio n. 21
0
        public FileStreamResult GetSample1()
        {
            var buffer = Sample1.GetSample(null);

            buffer.Seek(0, SeekOrigin.Begin);
            var result = new FileStreamResult(buffer, "application/pdf");

            return(result);
        }
Esempio n. 22
0
        public FileStreamResult GetSample1()
        {
            var          pdf    = Sample1.GetSample();
            string       s      = pdf.Output("a.pdf", OutputDevice.ReturnAsString);
            MemoryStream m      = new MemoryStream(FPdf.PrivateEncoding.GetBytes(s));
            var          result = new FileStreamResult(m, "application/pdf");

            return(result);
        }
        public void Serialize1()
        {
            Sample1 sample = new Sample1();

            JObject obj = JObject.FromObject(sample);

            JObject query = obj.GetObject("query");

            Assert.IsNull(query);
        }
        public void CreateSimpleObjectFromExistingClass()
        {
            var now = DateTime.Now;
            var obj = new Sample1() { AAA = now, BBB = "ASD" };
            var value = DictionaryHelper.FromAnonymous(obj);

            value.Count.Should().Be(2);
            value["AAA"].Should().Be(now);
            value["BBB"].Should().Be("ASD");
        }
Esempio n. 25
0
        public void TestToStringMultipleKeyWithNullKey()
        {
            var obj1   = new Sample1();
            var helper = new EqualityHelper <Sample1>(x => x.IntProp, x => x.StringProp);

            obj1.IntProp    = 123;
            obj1.StringProp = null;

            helper.ObjectToString(obj1).Should().Be("(IntProp=123 | StringProp=<null>)");
        }
Esempio n. 26
0
        public static void Main()
        {
            Sample1 del1 = new Sample1(SampleMethod1);

            del1 += SampleMethod2;
            int x = del1();     // the value returned by the last delegate function

            //that is called gets assigned to x i.e 2 in the given case
            Console.WriteLine(x);
        }
Esempio n. 27
0
        public void DynamicMethodInvoke()
        {
            var sample = new Sample1()
            {
                Id = 1
            };

            sample.AsDynamic().Apply(5);
            sample.Id.Should().Be(6);
        }
Esempio n. 28
0
 public ActionResult Edit([Bind(Include = "Id,Name")] Sample1 sample1)
 {
     if (ModelState.IsValid)
     {
         db.Entry(sample1).State = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     return(View(sample1));
 }
Esempio n. 29
0
 public IActionResult WebSample1()
 {
     using (var package = new ExcelPackage())
     {
         Sample1.InitWorkbook(package);
         var excelData = package.GetAsByteArray();
         var fileName  = "MyWorkbook.xlsx";
         return(File(excelData, ContentType, fileName));
     }
 }
Esempio n. 30
0
        static void Main(string[] args)
        {
            ISample sample1 = new Sample1();

            sample1.SayHello("小明");


            ISample sample2 = new Sample2();

            sample2.SayHello("Mike");


            ISample sample3 = new Sample3();

            sample3.SayHello("山本桑");


            Console.WriteLine("==== new 关键字 测试 ===");

            AbstractSample sample3a = new Sample3();

            sample3a.SayHello("山本桑");
            sample3a.SayEnd();

            Sample3 sample3b = new Sample3();

            sample3b.SayHello("山本桑");
            sample3b.SayEnd();



            Console.WriteLine("==== override 与 new 的区别 ===");


            Console.WriteLine("卡=普通卡!");
            Card card1 = new NormalCard();

            card1.LineUp();
            card1.TakeMoney();

            Console.WriteLine("卡=金卡!");
            Card card2 = new GoldCard();

            card2.LineUp();
            card2.TakeMoney();

            Console.WriteLine("金卡=金卡!");
            GoldCard card3 = new GoldCard();

            card3.LineUp();
            card3.TakeMoney();


            Console.ReadLine();
        }
        public void Deserialize2()
        {
            JObject obj = new JObject {
                { "query", new JObject() }
            };

            Sample1 value = obj.ToObject <Sample1>();

            Assert.IsNotNull(value.Query);
            Assert.IsNull(value.Query["hi"]);
        }
Esempio n. 32
0
        public void PersistenceSingle()
        {
            try
            {
                PersistenceClient <Guid, Sample1> repo;

                var p1 = new MicroservicePipeline("Local")
                         .AddChannelIncoming("request")
                         .AttachPersistenceManagerHandlerMemory(
                    keyMaker: (Sample1 e) => e.Id
                    , keyDeserializer: (s) => new Guid(s)
                    , versionPolicy: ((e) => e.VersionId.ToString("N").ToUpperInvariant(), (e) => e.VersionId = Guid.NewGuid(), true)
                    )
                         .AttachPersistenceClient(out repo)
                         .Revert()
                ;

                p1.Start();

                var sample = new Sample1()
                {
                    Message = "Hello mom"
                };
                var id = sample.Id;
                //Run a set of simple version entity tests.
                //Create
                Assert.IsTrue(repo.Create(sample).Result.IsSuccess);
                //Read
                var result = repo.Read(id).Result;
                Assert.IsTrue(result.IsSuccess);
                Assert.IsTrue(result.Entity.Message == "Hello mom");
                //Update success
                var rs = repo.Update(sample).Result;
                Assert.IsTrue(rs.IsSuccess);
                //We have enabled version policy and optimistic locking so the next command should fail.
                //Update fail as old version
                Assert.IsFalse(repo.Update(sample).Result.IsSuccess);
                //But this one should pass.
                //Update pass as new entity.
                Assert.IsTrue(repo.Update(rs.Entity).Result.IsSuccess);
                //Read
                Assert.IsTrue(repo.Read(sample.Id).Result.IsSuccess);
                //Delete
                Assert.IsTrue(repo.Delete(sample.Id).Result.IsSuccess);
                //Read fail.
                Assert.IsFalse(repo.Read(sample.Id).Result.IsSuccess);

                p1.Stop();
            }
            catch (Exception ex)
            {
                throw;
            }
        }
Esempio n. 33
0
 public void TestProtobufSimple()
 {
     var v1 = new Sample1 { X = 150, Y = "test" };
     var ps = new ProtobufSerializer();
     var result = ps.ToBytes(v1);
     CollectionAssert.AreEqual(new byte[] {
         0x08, 0x96, 0x01, 0x12, 0x04, (byte)'t', (byte)'e', (byte)'s', (byte)'t' }, result);
     CollectionAssert.AreEqual(result, ProtoBufNetToBytes(v1));
     var v2 = new Sample1();
     (new ProtobufDeserializer()).FromBytes(v2, result);
     Assert.AreEqual(v1.X, v2.X);
     Assert.AreEqual(v1.Y, v2.Y);
 }
Esempio n. 34
0
        public void TestDefault()
        {
            var js = new JsonSerializer();
            js.JsonOptions.Indent = "";
            js.JsonOptions.FieldSeparator = " ";

            var v1 = new Sample1 { X = 6, Y = "ttt" };
            var result1 = js.ToString(v1);
            Assert.AreEqual("{ \"X\":6 }", result1);
            var w1 = (Sample1)Sample1_JsonDeserializer.Instance.FromString(result1);
            Assert.AreEqual(6, w1.X);
            Assert.AreEqual("zzz", w1.Y);

            var v2 = new Sample2 { X = 5, Y = "5" };
            var result2 = js.ToString(v2);
            Assert.AreEqual("{ \"X\":5 }", result2);

            var v3 = new SampleDefault();
            Assert.AreEqual("{ }", js.ToString(new SampleDefault()));
            v3.B = "z";
            var result3 = js.ToString(v3);
            Assert.AreEqual("{ \"B\":\"z\" }", result3);
            var w3 = new SampleDefault();
            (new JsonDeserializer()).FromString(w3, result3);
            Assert.AreEqual(3, w3.A);
            Assert.AreEqual("z", w3.B);
            Assert.AreEqual(new SamplePoint { X = 7, Y = 2 }, w3.P);
        }
Esempio n. 35
0
        public void TestDefault()
        {
            var bs = new BinarySerializer();
            var bd = new BinaryDeserializer();
            var bdg = new BinaryDeserializerGen();

            var v1 = new Sample1 { X = 6, Y = "ttt" };
            var result1 = bs.ToBytes(v1);
            Assert.AreEqual(
                "20 01 00 " + XS(typeof(Sample1)) + " 02 00 " +
                XS("X", RoughType.Int, "Y", RoughType.String) +
                " 01 00 06 00 00 00 00 00", XS(result1));
            var w1 = (Sample1)bd.FromBytes(result1);
            Assert.AreEqual(6, w1.X);
            Assert.AreEqual("zzz", w1.Y);
            var w1g = (Sample1)bdg.FromBytes(result1);
            Assert.AreEqual(6, w1g.X);
            Assert.AreEqual("zzz", w1g.Y);

            var v2 = new Sample2 { X = 5, Y = "5" };
            var result2 = bs.ToBytes(v2);
            Assert.AreEqual(
                "20 02 00 " + XS(typeof(Sample2)) + " 02 00 " +
                XS("X", RoughType.Int, "Y", RoughType.String) +
                " 01 00 05 00 00 00 00 00", XS(result2));
            Assert.IsInstanceOfType(bd.FromBytes(result2), typeof(Sample2));

            var v3 = new SampleDefault();
            var result3 = bs.ToBytes(new SampleDefault());
            Assert.AreEqual(
                "20 03 00 " + XS(typeof(SampleDefault)) + " 03 00 " +
                XS("A", RoughType.Int, "B", RoughType.String, "P", RoughType.Record) + " 00 00",
                XS(result3));
            Assert.IsInstanceOfType(bd.FromBytes(result3), typeof(SampleDefault));
            v3.B = "z";
            var result3m = bs.ToBytes(v3);
            Assert.AreEqual("20 03 00 02 00 " + XS("z") + " 00 00", XS(result3m));
            var w3 = new SampleDefault();
            bd.FromBytes(w3, result3m);
            Assert.AreEqual(3, w3.A);
            Assert.AreEqual("z", w3.B);
            Assert.AreEqual(new SamplePoint { X = 7, Y = 2 }, w3.P);

            var result4 = SX(
                "20 01 00 " + XS(typeof(SampleDefault)) + " 02 00 " +
                XS("A", RoughType.Int, "P", RoughType.Record) + " 01 00 05 00 00 00 " +
                "02 00 02 00 " + XS(typeof(SamplePoint)) + " 02 00 " +
                XS("X", RoughType.Int, "Y", RoughType.Int) + " 04 00 00 00 06 00 00 00 " +
                "00 00"
            );
            bdg.ClearClassIds();
            var w4 = bdg.FromBytes<SampleDefault>(result4);
            Assert.AreEqual(5, w4.A);
            Assert.AreEqual("default", w4.B);
            Assert.AreEqual(new SamplePoint { X = 4, Y = 6 }, w4.P);
        }
Esempio n. 36
0
        public void TestErrors()
        {
            var bd = new BinaryDeserializer();
            bd.Options.AllowEmptyTypes = true;
            var bdg = new BinaryDeserializerGenerator();

            XAssert.Throws<YuzuException>(() => bdg.Generate<ISample>(), "ISample");
            XAssert.Throws<YuzuException>(() => bdg.Generate<SampleAbstract>(), "SampleAbstract");
            XAssert.Throws<YuzuException>(() => bd.FromBytes<int>(new byte[] { 0xFF }), "255");

            XAssert.Throws<YuzuException>(() => bd.FromBytes(new byte[] { 0xFF }), "255");
            XAssert.Throws<YuzuException>(() => bd.FromBytes<int>(new byte[] { 0xFF }), "255");
            XAssert.Throws<YuzuException>(() => bd.FromBytes<int>(new byte[] { 07 }), "Int32");

            XAssert.Throws<YuzuException>(() => bd.FromBytes(new byte[] { (byte)RoughType.Any }), "pure");

            XAssert.Throws<YuzuException>(() => bd.FromBytes<Sample1>(SX(
                "20 01 00 " + XS("notype") + " 00 00 00 00"
            )), "YuzuUnknown");

            var w = new Sample1();
            XAssert.Throws<YuzuException>(() => bd.FromBytes(w, SX(
                "20 02 00 " + XS(typeof(Empty)) + " 00 00 00 00"
            )), "Sample1");

            var w2 = new Sample2Allow();
            XAssert.Throws<YuzuException>(() => bd.FromBytes(w2, SX(
                "20 02 00 00 00"
            )), "Sample2Allow");

            XAssert.Throws<YuzuException>(() => bd.FromBytes(w, SX("20 05 00")), "5");

            XAssert.Throws<YuzuException>(() => bd.FromBytes(w, SX(
                "20 03 00 " + XS(typeof(Sample1)) + " 00 00 00 00"
            )), " X ");

            XAssert.Throws<YuzuException>(() => bd.FromBytes(w, SX(
                "20 03 00 " + XS(typeof(Empty)) + " 00 01 " + XS("New", RoughType.Int) + " 00 00"
            )), "New");

            XAssert.Throws<YuzuException>(() => bd.FromBytes(w, SX(
                "20 03 00 " + XS(typeof(Sample1)) + " 00 01 " + XS("X", RoughType.String) + " 00 00"
            )), "Int32");
        }
Esempio n. 37
0
        public void TestSimple()
        {
            var js = new JsonSerializer();
            js.Options.AllowEmptyTypes = true;
            Assert.AreEqual("{\n}", js.ToString(new Empty()));

            var v1 = new Sample1 { X = 345, Y = "test" };
            js.JsonOptions.Indent = "";

            var result = js.ToString(v1);
            Assert.AreEqual("{\n\"X\":345,\n\"Y\":\"test\"\n}", result);
            Sample1 v2 = new Sample1();

            var jd = new JsonDeserializer();
            jd.FromString(v2, result);
            Assert.AreEqual(v1.X, v2.X);
            Assert.AreEqual(v1.Y, v2.Y);

            jd.FromString(v2, "{\"X\":999}");
            Assert.AreEqual(999, v2.X);
            Assert.AreEqual(v1.Y, v2.Y);

            v1.X = int.MaxValue;
            jd.FromString(v2, js.ToString(v1));
            Assert.AreEqual(v1.X, v2.X);

            v1.X = int.MinValue;
            jd.FromString(v2, js.ToString(v1));
            Assert.AreEqual(v1.X, v2.X);
        }
Esempio n. 38
0
File: Main.cs Progetto: klenin/Yuzu
        public void TestCodeAssignSimple()
        {
            var v1 = new Sample1 { X = 150, Y = "test" };
            var cs = new CodeAssignSerializer();
            var result1 = cs.ToString(v1);
            Assert.AreEqual("void Init(Sample1 obj) {\n\tobj.X = 150;\n\tobj.Y = \"test\";\n}\n", result1);

            var v2 = new Sample2 { X = 150, Y = "test" };
            var result2 = cs.ToString(v2);
            Assert.AreEqual("void Init(Sample2 obj) {\n\tobj.X = 150;\n\tobj.Y = \"test\";\n}\n", result2);
        }
Esempio n. 39
0
        public void TestGenerated()
        {
            var str =
                "20 01 00 " + XS(typeof(Sample3)) + " 03 00 " +
                XS("S1", RoughType.Record, "F", RoughType.Int, "S2", RoughType.Record) +
                " 01 00 02 00 " + XS(typeof(Sample1)) +
                " 02 00 " + XS("X", RoughType.Int, "Y", RoughType.String) +
                " 01 00 59 01 00 00 02 00 " + XS("test") + " 00 00 " +
                "02 00 DE 00 00 00 " +
                "03 00 03 00 " + XS(typeof(Sample2)) +
                " 02 00 " + XS("X", RoughType.Int, "Y", RoughType.String) +
                " 01 00 A6 FE FF FF 02 00 " + XS("test1") + " 00 00 00 00";

            var bd = new BinaryDeserializerGen();
            bd.Options.TagMode = TagMode.Names;
            var w = (Sample3)bd.FromBytes(SX(str));
            Assert.AreEqual(345, w.S1.X);
            Assert.AreEqual("test", w.S1.Y);
            Assert.AreEqual(222, w.F);
            Assert.AreEqual(-346, w.S2.X);
            Assert.AreEqual("test1", w.S2.Y);

            var w1 = new Sample1();
            bd.FromBytes(w1, SX("20 02 00 01 00 58 00 00 00 00 00"));
            Assert.IsInstanceOfType(w1, typeof(Sample1));
            Assert.AreEqual(88, w1.X);

            var w2 = bd.FromBytes(SX("20 02 00 01 00 63 00 00 00 00 00"));
            Assert.IsInstanceOfType(w2, typeof(Sample1));
            Assert.AreEqual(99, ((Sample1)w2).X);

            var w3 = new SampleMemberI();
            bd.FromBytes(w3, SX(
                "20 04 00 " + XS(typeof(SampleMemberI)) + " 01 00 " + XS("X", RoughType.Int) + " 00 00"));
            Assert.AreEqual(71, ((SampleMemberI)w3).X);
        }
Esempio n. 40
0
        public void TestSimple()
        {
            var bs = new BinarySerializer();
            bs.Options.AllowEmptyTypes = true;
            Assert.AreEqual(
                XS(RoughType.Record) + " 01 00 " + XS(typeof(Empty)) + " 00 00 00 00",
                XS(bs.ToBytes(new Empty())));

            var v1 = new Sample1 { X = 345, Y = "test" };

            bs.ClearClassIds();
            var result = bs.ToBytes(v1);
            Assert.AreEqual(
                XS(RoughType.Record) + " 01 00 " + XS(typeof(Sample1)) + " 02 00 " +
                XS("X", RoughType.Int, "Y", RoughType.String) +
                " 01 00 59 01 00 00 02 00 " + XS("test") + " 00 00", XS(result));
            Sample1 v2 = new Sample1();

            var bd = new BinaryDeserializer();
            bd.FromBytes(v2, result);
            Assert.AreEqual(v1.X, v2.X);
            Assert.AreEqual(v1.Y, v2.Y);

            bd.FromBytes(v2, new byte[] { 0x20, 01, 00, 01, 00, 0xE7, 03, 00, 00, 00, 00 });
            Assert.AreEqual(999, v2.X);
            Assert.AreEqual(v1.Y, v2.Y);

            v1.X = int.MaxValue;
            bd.FromBytes(v2, bs.ToBytes(v1));
            Assert.AreEqual(v1.X, v2.X);

            v1.X = int.MaxValue;
            bd.FromBytes(v2, bs.ToBytes(v1));
            Assert.AreEqual(v1.X, v2.X);
        }
 public void GetSample1()
 {
     var sample = new Sample1();
     sample.Add(10,100);
 }
Esempio n. 42
0
        public void TestGenerated()
        {
            const string str =
                "{\n\"S1\":" +
                "{\n\"X\":345,\n\"Y\":\"test\"\n},\n" +
                "\"F\":222,\n" +
                "\"S2\":" +
                "{\n\"X\":-346,\n\"Y\":\"test1\"\n}\n" +
                "}";

            var jd = new Sample3_JsonDeserializer();
            var w = (Sample3)jd.FromString(str);
            Assert.AreEqual(345, w.S1.X);
            Assert.AreEqual("test", w.S1.Y);
            Assert.AreEqual(222, w.F);
            Assert.AreEqual(-346, w.S2.X);
            Assert.AreEqual("test1", w.S2.Y);

            var jdg = new JsonDeserializerGenerator();
            jdg.Assembly = GetType().Assembly;

            var w1 = new Sample1();
            jdg.FromString(w1, "{\"X\":88}");
            Assert.IsInstanceOfType(w1, typeof(Sample1));
            Assert.AreEqual(88, w1.X);

            var w2 = jdg.FromString("{\"class\":\"YuzuTest.Sample1, YuzuTest\",\"X\":99}");
            Assert.IsInstanceOfType(w2, typeof(Sample1));
            Assert.AreEqual(99, ((Sample1)w2).X);

            var w3 = new SampleMemberI();
            jdg.FromString(w3, "{\"class\":\"YuzuTest.SampleMemberI, YuzuTest\"}");
            Assert.AreEqual(71, ((SampleMemberI)w3).X);
        }
Esempio n. 43
0
        public void TestEscape()
        {
            var js = new JsonSerializer();
            js.JsonOptions.Indent = "";
            js.JsonOptions.FieldSeparator = "";

            var s = "\"/{\u0001}\n\t\"\"";
            var v = new Sample1 { Y = s };
            var result = js.ToString(v);
            Assert.AreEqual("{\"X\":0,\"Y\":\"\\\"/{\\u0001}\\n\\t\\\"\\\"\"}", result);

            var w = new Sample1();
            var jd = new JsonDeserializer();
            jd.FromString(w, result);
            Assert.AreEqual(s, w.Y);

            v.Y = result;
            var result1 = js.ToString(v);
            jd.FromString(w, result1);
            Assert.AreEqual(result, w.Y);

            v.Y = "привет";
            var result2 = js.ToString(v);
            Assert.AreEqual("{\"X\":0,\"Y\":\"привет\"}", result2);

            jd.FromString(w, result2);
            Assert.AreEqual(v.Y, w.Y);
            jd.FromString(w, "{\"X\":0,\"Y\":\"\u043F\u0440\u0438\u0432\u0435\u0442\"}");
            Assert.AreEqual(v.Y, w.Y);
        }
Esempio n. 44
0
        public void TestErrors()
        {
            var js = new JsonSerializer();
            XAssert.Throws<YuzuException>(() => js.ToString(new Empty()), "Empty");
            XAssert.Throws<YuzuException>(() => js.ToString(new SampleCollectionWithField<int>()), "collection");
            XAssert.Throws<YuzuException>(() => js.ToString(new SampleInterfacedFieldDup()), "X");
            XAssert.Throws<YuzuException>(() => js.ToString(new BadMerge1()), "merge");
            XAssert.Throws<YuzuException>(() => js.ToString(new BadMerge2()), "merge");

            var jd = new JsonDeserializer();
            var w = new Sample1();
            XAssert.Throws<YuzuException>(() => jd.FromString(w, "{}"), "X");
            XAssert.Throws<YuzuException>(() => jd.FromString("{null:1}"), "'n'");
            XAssert.Throws<YuzuException>(() => jd.FromString(w, "{ \"X\" }"), ":");
            XAssert.Throws<YuzuException>(() => jd.FromString(w, "nn"), "'u'");
            XAssert.Throws<YuzuException>(() => jd.FromString(w, "{ \"X\":1, \"Y\": \"\\z\" }"), "z");
            XAssert.Throws<YuzuException>(() => jd.FromString(w, "{ \"X\":1, \"Y\": \"\\uQ\" }"), "Q");
            XAssert.Throws<YuzuException>(() => jd.FromString(new SampleBool(), "{ \"B\": 1 }"), "1");
            XAssert.Throws<YuzuException>(() => jd.FromString(w, "{ ,}"), ",");
            XAssert.Throws<YuzuException>(() => jd.FromString(w, "{ \"Y\": \"q\" }"), "'X'");
            XAssert.Throws<YuzuException>(() => jd.FromString(w, "[]"), "'Sample1'");
            XAssert.Throws<YuzuException>(() => jd.FromString(w, "{ \"class\": \"Q\" }"), "'Q'");
            XAssert.Throws<YuzuException>(() => jd.FromString(w, "{ \"class\": \"YuzuTest.Sample2, YuzuTest\" }"), ".Sample2");
            XAssert.Throws<YuzuException>(() => jd.FromString(
                new Sample2Allow(), "{ \"class\": \"YuzuTest.Sample1, YuzuTest\" }"), ".Sample1");
            XAssert.Throws<YuzuException>(() => jd.FromString(new SamplePoint(), "[ \"QQ\" ]"), "");
            XAssert.Throws<YuzuException>(() => jd.FromString(new object(), "{}"), "object");
            XAssert.Throws<EndOfStreamException>(() => jd.FromString(""), "");
            XAssert.Throws<EndOfStreamException>(() => jd.FromString(w, "{ \"X\": 1"));
            XAssert.Throws<YuzuException>(() => jd.FromString(
                "{\"class\":\"YuzuTest.SampleInterfaceField, YuzuTest\",\"I\":{}}"), "class");
            XAssert.Throws<YuzuException>(() => jd.FromString(
                "{\"class\":\"YuzuTest.SampleInterfaceField, YuzuTest\",\"I\":{\"class\":\"YuzuTest.Sample1, YuzuTest\"}}"),
                "ISample");

            jd.Options.ReportErrorPosition = true;
            XAssert.Throws<YuzuException>(() => jd.FromString(w, "      z"), "7");
            jd.Options.ReportErrorPosition = false;
            try {
                jd.FromString(w, "      z");
            }
            catch (YuzuException e) {
                Assert.IsFalse(e.Message.Contains("7"));
            }
        }
Esempio n. 45
0
        public void TestEscape()
        {
            var bs = new BinarySerializer();

            var s = "\"/{\u0001}\n\t\"\"";
            var v = new Sample1 { Y = s };
            var result = bs.ToBytes(v);
            Assert.AreEqual(
                "20 01 00 " + XS(typeof(Sample1)) + " 02 00 " +
                XS("X", RoughType.Int, "Y", RoughType.String) +
                " 01 00 00 00 00 00 02 00 " + XS(s) + " 00 00",
                XS(result));

            var w = new Sample1();
            var bd = new BinaryDeserializer();
            bd.FromBytes(w, result);
            Assert.AreEqual(s, w.Y);

            v.Y = "привет";
            var result2 = bs.ToBytes(v);
            Assert.AreEqual(
                "20 01 00 01 00 00 00 00 00 02 00 0C " +
                XS(Encoding.UTF8.GetBytes("привет")) + " 00 00",
                XS(result2));
            bd.FromBytes(w, result2);
            Assert.AreEqual(v.Y, w.Y);

            var ms = new MemoryStream(result2.Length);
            ms.Write(result2, 0, result2.Length);
            ms.Position = 0;
            bd.FromReader(w, new UnsafeBinaryReader(ms));
            Assert.AreEqual(v.Y, w.Y);
        }