Esempio n. 1
0
        public void complexTest2()
        {
            using (dynamic l = new ConariX(gCfgUnlib))
            {
                IntPtr ptr = l.get_TSpecB_A_ptr <IntPtr>();
                Assert.NotEqual(IntPtr.Zero, ptr);

                /*
                 *  struct TSpecA
                 *  {
                 *      int a;
                 *      int b;
                 *  };
                 *
                 *  struct TSpecB
                 *  {
                 *      bool d;
                 *      TSpecA* s;
                 *  };
                 *
                 *  A->a = 4;
                 *  A->b = -8;
                 *
                 *  B->d = true;
                 *  B->s = TSpecA*;
                 *
                 */
                var TSpecBPtr = NativeData
                                ._(ptr)
                                .t <bool>("d")
                                .t <IntPtr>("s")
                                .AlignSizeByMax;

                Assert.Equal(2, TSpecBPtr.Raw.Type.Fields.Count);

                dynamic dlr = TSpecBPtr.Raw.Type;

                IntPtr addrA = dlr.s;

                Assert.Equal(true, dlr.d);
                Assert.NotEqual(IntPtr.Zero, addrA);

                // B->A

                var TSpecAPtr = NativeData
                                ._(addrA)
                                .align <Int32>(2, "a", "b");

                Assert.Equal(2, TSpecAPtr.Raw.Type.Fields.Count);

                dynamic s = TSpecAPtr.Raw.Type;

                Assert.Equal(4, s.a);  // B->s->a
                Assert.Equal(-8, s.b); // B->s->b

                // the test with reading memory again

                dynamic attempt2 = NativeData
                                   ._(addrA)
                                   .align <Int32>(2, "a", "b")
                                   .Raw.Type;

                Assert.Equal(4, attempt2.a);  // B->s->a
                Assert.Equal(-8, attempt2.b); // B->s->b


                // free mem

                //var dirtyA = addrA;

                //l.free(addrA);

                //dynamic hole = NativeData
                //                    ._(dirtyA)
                //                    .align<Int32>(2, "a", "b")
                //                    .Raw.Type;

                //int _a = hole.a; // ~ 0
                //int _b = hole.b; // ~ 0
            }
        }