public void DeshacerCambiosEnObjetoDatos()
        {
            // arrange
            Log controlador = new Log();
            //FabricaHistorial fabrica = new FabricaHistorial();
            IFabrica     fabrica = new FabricaHistorial(controlador);
            IObjetoDatos od      = fabrica.Crear(HelperTipo.ObtenerTipo());

            // act
            bool     valorBoolean  = od.ObtenerBoolean(0);
            byte     valorByte     = od.ObtenerByte(1);
            char     valorChar     = od.ObtenerChar(2);
            DateTime valorDateTime = od.ObtenerDateTime(3);
            var      valorDecimal  = od.ObtenerDecimal(4);
            var      valorDouble   = od.ObtenerDouble(5);
            var      valorFloat    = od.ObtenerFloat(6);
            var      valorInteger  = od.ObtenerInteger(7);
            var      valorLong     = od.ObtenerLong(8);
            var      valorSByte    = od.ObtenerSByte(9);
            var      valorShort    = od.ObtenerShort(10);
            var      valorString   = od.ObtenerString(11);
            var      valorUInteger = od.ObtenerUInteger(12);
            var      valorULong    = od.ObtenerULong(13);
            var      valorUShort   = od.ObtenerUShort(14);

            // establecer valores
            //EstablecerValoresPorIndice(od);
            Helper.Construir(od);

            // deshacer cambios
            controlador.Deshacer();

            //// establecer valores
            ////EstablecerValoresPorTipoPorIndice(od);
            //Helper.Construir(od);

            //// deshacer cambios
            //controlador.Deshacer();

            // assert
            Assert.AreEqual(od.ObtenerBoolean(0), valorBoolean, $"Se esperaba {valorBoolean}");
            Assert.AreEqual(od.ObtenerByte(1), valorByte, $"Se esperaba {valorByte}");
            Assert.AreEqual(od.ObtenerChar(2), valorChar, $"Se esperaba {valorChar}");
            Assert.AreEqual(od.ObtenerDateTime(3), valorDateTime, $"Se esperaba {valorDateTime}");
            Assert.AreEqual(od.ObtenerDecimal(4), valorDecimal, $"Se esperaba {valorDecimal}");
            Assert.AreEqual(od.ObtenerDouble(5), valorDouble, $"Se esperaba {valorDouble}");
            Assert.AreEqual(od.ObtenerFloat(6), valorFloat, $"Se esperaba {valorFloat}");
            Assert.AreEqual(od.ObtenerInteger(7), valorInteger, $"Se esperaba {valorInteger}");
            Assert.AreEqual(od.ObtenerLong(8), valorInteger, $"Se esperaba {valorInteger}");
            Assert.AreEqual(od.ObtenerSByte(9), valorSByte, $"Se esperaba {valorSByte}");
            Assert.AreEqual(od.ObtenerShort(10), valorShort, $"Se esperaba {valorShort}");
            Assert.AreEqual(od.ObtenerString(11), valorString, $"Se esperaba {valorString ?? ""}");
            Assert.AreEqual(od.ObtenerUInteger(12), valorUInteger, $"Se esperaba {valorUInteger}");
            Assert.AreEqual(od.ObtenerULong(13), valorULong, $"Se esperaba {valorULong}");
            Assert.AreEqual(od.ObtenerUShort(14), valorUShort, $"Se esperaba {valorUShort}");
        }
        public void RecuperarInstantaneaEnObjetoDatos()
        {
            // arrange
            Log log = new Log();
            //FabricaHistorial fabrica = new FabricaHistorial();
            IFabrica     fabrica = new FabricaHistorial(log);
            IObjetoDatos od      = fabrica.Crear(HelperTipo.ObtenerTipo());

            // act
            bool     valorBoolean  = od.ObtenerBoolean(0);
            byte     valorByte     = od.ObtenerByte(1);
            char     valorChar     = od.ObtenerChar(2);
            DateTime valorDateTime = od.ObtenerDateTime(3);
            var      valorDecimal  = od.ObtenerDecimal(4);
            var      valorDouble   = od.ObtenerDouble(5);
            var      valorFloat    = od.ObtenerFloat(6);
            var      valorInteger  = od.ObtenerInteger(7);
            var      valorLong     = od.ObtenerLong(8);
            var      valorSByte    = od.ObtenerSByte(9);
            var      valorShort    = od.ObtenerShort(10);
            var      valorString   = od.ObtenerString(11);
            var      valorUInteger = od.ObtenerUInteger(12);
            var      valorULong    = od.ObtenerULong(13);
            var      valorUShort   = od.ObtenerUShort(14);

            // establecer valores
            var instantanea1 = log.CrearInstantanea();

            od.EstablecerBoolean("atributoBoolean", true);

            var instantanea2 = log.CrearInstantanea();

            od.EstablecerByte("atributoByte", byte.MaxValue);

            var instantanea3 = log.CrearInstantanea();

            od.EstablecerChar("atributoChar", char.MaxValue);

            var instantanea4 = log.CrearInstantanea();

            od.EstablecerDateTime("atributoDateTime", DateTime.MaxValue);

            // recuperar
            log.Recuperar(instantanea3);

            // assert
            Assert.AreEqual(od.ObtenerBoolean(0), true, $"Se esperaba {valorBoolean}");
            Assert.AreEqual(od.ObtenerByte(1), byte.MaxValue, $"Se esperaba {valorByte}");
            Assert.AreEqual(od.ObtenerChar(2), valorChar, $"Se esperaba {valorChar}");
            Assert.AreEqual(od.ObtenerDateTime(3), valorDateTime, $"Se esperaba {valorDateTime}");

            // recuperar
            log.Recuperar(instantanea1);

            // assert
            Assert.AreEqual(od.ObtenerBoolean(0), valorBoolean, $"Se esperaba {valorBoolean}");
            Assert.AreEqual(od.ObtenerByte(1), valorByte, $"Se esperaba {valorByte}");
            Assert.AreEqual(od.ObtenerChar(2), valorChar, $"Se esperaba {valorChar}");
            Assert.AreEqual(od.ObtenerDateTime(3), valorDateTime, $"Se esperaba {valorDateTime}");
        }
示例#3
0
        public void EvaluarObjetoDatosPathObtenerPorTipo()
        {
            IObjetoDatos od = Helper.Crear(_tipox);

            Helper.Construir(od, 2, 0);

            string ruta = "ReferenciaObjetoDatos";

            bool     valorBoolean  = true;
            byte     valorByte     = 125;
            char     valorChar     = 'D';
            DateTime valorDateTime = DateTime.Now;
            decimal  valorDecimal  = new decimal(15896658.100245);
            double   valorDouble   = 448995.55698;
            float    valorFloat    = (float)56625.55;
            int      valorInteger  = -102458;
            long     valorLong     = -89665522321;
            sbyte    valorSByte    = 89;
            short    valorShort    = 5444;
            string   valorString   = "cadena de texto";
            uint     valorUInteger = 89955212;
            ulong    valorULong    = 788554421056;
            ushort   valorUShort   = 9035;

            od.EstablecerBoolean($"{ruta}/atributoBoolean", valorBoolean);
            od.EstablecerByte($"{ruta}/atributoByte", valorByte);
            od.EstablecerChar($"{ruta}/atributoChar", valorChar);
            od.EstablecerDateTime($"{ruta}/atributoDateTime", valorDateTime);
            od.EstablecerDecimal($"{ruta}/atributoDecimal", valorDecimal);
            od.EstablecerDouble($"{ruta}/atributoDouble", valorDouble);
            od.EstablecerFloat($"{ruta}/atributoFloat", valorFloat);
            od.EstablecerInteger($"{ruta}/atributoInteger", valorInteger);
            od.EstablecerLong($"{ruta}/atributoLong", valorLong);
            od.EstablecerSByte($"{ruta}/atributoSByte", valorSByte);
            od.EstablecerShort($"{ruta}/atributoShort", valorShort);
            od.EstablecerString($"{ruta}/atributoString", valorString);
            od.EstablecerUInteger($"{ruta}/atributoUInteger", valorUInteger);
            od.EstablecerULong($"{ruta}/atributoULong", valorULong);
            od.EstablecerUShort($"{ruta}/atributoUShort", valorUShort);

            Assert.AreEqual(valorBoolean, od.ObtenerBoolean($"{ruta}/atributoBoolean"));
            Assert.AreEqual(valorByte, od.ObtenerByte($"{ruta}/atributoByte"));
            Assert.AreEqual(valorChar, od.ObtenerChar($"{ruta}/atributoChar"));
            Assert.AreEqual(valorDateTime, od.ObtenerDateTime($"{ruta}/atributoDateTime"));
            Assert.AreEqual(valorDecimal, od.ObtenerDecimal($"{ruta}/atributoDecimal"));
            Assert.AreEqual(valorDouble, od.ObtenerDouble($"{ruta}/atributoDouble"));
            Assert.AreEqual(valorFloat, od.ObtenerFloat($"{ruta}/atributoFloat"));
            Assert.AreEqual(valorInteger, od.ObtenerInteger($"{ruta}/atributoInteger"));
            Assert.AreEqual(valorLong, od.ObtenerLong($"{ruta}/atributoLong"));
            Assert.AreEqual(valorSByte, od.ObtenerSByte($"{ruta}/atributoSByte"));
            Assert.AreEqual(valorShort, od.ObtenerShort($"{ruta}/atributoShort"));
            Assert.AreEqual(valorString, od.ObtenerString($"{ruta}/atributoString"));
            Assert.AreEqual(valorUInteger, od.ObtenerUInteger($"{ruta}/atributoUInteger"));
            Assert.AreEqual(valorULong, od.ObtenerULong($"{ruta}/atributoULong"));
            Assert.AreEqual(valorUShort, od.ObtenerUShort($"{ruta}/atributoUShort"));
        }
示例#4
0
        public void EvaluarEstablecerPorTipoPorNombre()
        {
            IObjetoDatos od  = Fabrica.Instancia.Crear(_tipo);
            Random       rnd = new Random();

            bool     valorBoolean  = true;
            byte     valorByte     = byte.MaxValue;
            char     valorChar     = char.MaxValue;
            DateTime valorDateTime = DateTime.MaxValue;
            decimal  valorDecimal  = decimal.MaxValue;
            double   valorDouble   = double.MaxValue;
            float    valorFloat    = float.MaxValue;
            int      valorInteger  = int.MaxValue;
            long     valorLong     = long.MaxValue;
            sbyte    valorSByte    = sbyte.MaxValue;
            short    valorShort    = short.MaxValue;
            string   valorString   = "abcdefghijklmnoprstuvwxyz";
            uint     valorUInteger = uint.MaxValue;
            ulong    valorULong    = ulong.MaxValue;
            ushort   valorUShort   = ushort.MaxValue;

            od.EstablecerBoolean("atributoBoolean", valorBoolean);
            od.EstablecerByte("atributoByte", valorByte);
            od.EstablecerChar("atributoChar", valorChar);
            od.EstablecerDateTime("atributoDateTime", valorDateTime);
            od.EstablecerDecimal("atributoDecimal", valorDecimal);
            od.EstablecerDouble("atributoDouble", valorDouble);
            od.EstablecerFloat("atributoFloat", valorFloat);
            od.EstablecerInteger("atributoInteger", valorInteger);
            od.EstablecerLong("atributoLong", valorLong);
            od.EstablecerSByte("atributoSByte", valorSByte);
            od.EstablecerShort("atributoShort", valorShort);
            od.EstablecerString("atributoString", valorString);
            od.EstablecerUInteger("atributoUInteger", valorUInteger);
            od.EstablecerULong("atributoULong", valorULong);
            od.EstablecerUShort("atributoUShort", valorUShort);

            Assert.AreEqual(od.ObtenerBoolean("atributoBoolean"), valorBoolean);
            Assert.AreEqual(od.ObtenerByte("atributoByte"), valorByte);
            Assert.AreEqual(od.ObtenerChar("atributoChar"), valorChar);
            Assert.AreEqual(od.ObtenerDateTime("atributoDateTime"), valorDateTime);
            Assert.AreEqual(od.ObtenerDecimal("atributoDecimal"), valorDecimal);
            Assert.AreEqual(od.ObtenerDouble("atributoDouble"), valorDouble);
            Assert.AreEqual(od.ObtenerFloat("atributoFloat"), valorFloat);
            Assert.AreEqual(od.ObtenerInteger("atributoInteger"), valorInteger);
            Assert.AreEqual(od.ObtenerLong("atributoLong"), valorLong);
            Assert.AreEqual(od.ObtenerSByte("atributoSByte"), valorSByte);
            Assert.AreEqual(od.ObtenerShort("atributoShort"), valorShort);
            Assert.AreEqual(od.ObtenerString("atributoString"), valorString);
            Assert.AreEqual(od.ObtenerUInteger("atributoUInteger"), valorUInteger);
            Assert.AreEqual(od.ObtenerULong("atributoULong"), valorULong);
            Assert.AreEqual(od.ObtenerUShort("atributoUShort"), valorUShort);
        }
示例#5
0
        public void EvaluarEstablecerPorTipoPorIndice()
        {
            IObjetoDatos od  = Fabrica.Instancia.Crear(_tipo);
            Random       rnd = new Random();

            bool     valorBoolean  = true;
            byte     valorByte     = byte.MaxValue;
            char     valorChar     = char.MaxValue;
            DateTime valorDateTime = DateTime.MaxValue;
            decimal  valorDecimal  = decimal.MaxValue;
            double   valorDouble   = double.MaxValue;
            float    valorFloat    = float.MaxValue;
            int      valorInteger  = int.MaxValue;
            long     valorLong     = long.MaxValue;
            sbyte    valorSByte    = sbyte.MaxValue;
            short    valorShort    = short.MaxValue;
            string   valorString   = "abcdefghijklmnoprstuvwxyz";
            uint     valorUInteger = uint.MaxValue;
            ulong    valorULong    = ulong.MaxValue;
            ushort   valorUShort   = ushort.MaxValue;

            od.EstablecerBoolean(0, valorBoolean);
            od.EstablecerByte(1, valorByte);
            od.EstablecerChar(2, valorChar);
            od.EstablecerDateTime(3, valorDateTime);
            od.EstablecerDecimal(4, valorDecimal);
            od.EstablecerDouble(5, valorDouble);
            od.EstablecerFloat(6, valorFloat);
            od.EstablecerInteger(7, valorInteger);
            od.EstablecerLong(8, valorLong);
            od.EstablecerSByte(9, valorSByte);
            od.EstablecerShort(10, valorShort);
            od.EstablecerString(11, valorString);
            od.EstablecerUInteger(12, valorUInteger);
            od.EstablecerULong(13, valorULong);
            od.EstablecerUShort(14, valorUShort);

            Assert.AreEqual(od.ObtenerBoolean(0), valorBoolean);
            Assert.AreEqual(od.ObtenerByte(1), valorByte);
            Assert.AreEqual(od.ObtenerChar(2), valorChar);
            Assert.AreEqual(od.ObtenerDateTime(3), valorDateTime);
            Assert.AreEqual(od.ObtenerDecimal(4), valorDecimal);
            Assert.AreEqual(od.ObtenerDouble(5), valorDouble);
            Assert.AreEqual(od.ObtenerFloat(6), valorFloat);
            Assert.AreEqual(od.ObtenerInteger(7), valorInteger);
            Assert.AreEqual(od.ObtenerLong(8), valorLong);
            Assert.AreEqual(od.ObtenerSByte(9), valorSByte);
            Assert.AreEqual(od.ObtenerShort(10), valorShort);
            Assert.AreEqual(od.ObtenerString(11), valorString);
            Assert.AreEqual(od.ObtenerUInteger(12), valorUInteger);
            Assert.AreEqual(od.ObtenerULong(13), valorULong);
            Assert.AreEqual(od.ObtenerUShort(14), valorUShort);
        }
示例#6
0
        protected virtual void Escribir(IObjetoDatos od, IPropiedad propiedad)
        {
            switch (propiedad.Tipo.Nombre)
            {
            case "Boolean":
                EscribirBoolean(propiedad, od.ObtenerBoolean(propiedad));
                break;

            case "Byte":
                EscribirByte(propiedad, od.ObtenerByte(propiedad));
                break;

            case "Char":
                EscribirChar(propiedad, od.ObtenerChar(propiedad));
                break;

            case "DateTime":
                EscribirDateTime(propiedad, od.ObtenerDateTime(propiedad));
                break;

            case "Decimal":
                EscribirDecimal(propiedad, od.ObtenerDecimal(propiedad));
                break;

            case "Double":
                EscribirDouble(propiedad, od.ObtenerDouble(propiedad));
                break;

            case "Single":
                EscribirFloat(propiedad, od.ObtenerFloat(propiedad));
                break;

            case "Int32":
                EscribirInteger(propiedad, od.ObtenerInteger(propiedad));
                break;

            case "Int64":
                EscribirLong(propiedad, od.ObtenerLong(propiedad));
                break;

            case "SByte":
                EscribirSByte(propiedad, od.ObtenerSByte(propiedad));
                break;

            case "Int16":
                EscribirShort(propiedad, od.ObtenerShort(propiedad));
                break;

            case "String":
                EscribirString(propiedad, od.ObtenerString(propiedad));
                break;

            case "UInt32":
                EscribirUInteger(propiedad, od.ObtenerUInteger(propiedad));
                break;

            case "UInt64":
                EscribirULong(propiedad, od.ObtenerULong(propiedad));
                break;

            case "UInt16":
                EscribirUShort(propiedad, od.ObtenerUShort(propiedad));
                break;
            }
        }
        public static void Comparar(IObjetoDatos od1, IObjetoDatos od2)
        {
            Assert.AreEqual(od1.ObtenerInteger("atributoId"), od2.ObtenerInteger("atributoId"));
            Assert.AreEqual(od1.ObtenerByte("atributoBoolean"), od2.ObtenerByte("atributoBoolean"));
            Assert.AreEqual(od1.ObtenerByte("atributoByte"), od2.ObtenerByte("atributoByte"));
            Assert.AreEqual(od1.ObtenerChar("atributoChar"), od2.ObtenerChar("atributoChar"));
            Assert.AreEqual(od1.ObtenerDateTime("atributoDateTime").Date, od2.ObtenerDateTime("atributoDateTime").Date);
            Assert.AreEqual(od1.ObtenerDateTime("atributoDateTime").Hour, od2.ObtenerDateTime("atributoDateTime").Hour);
            Assert.AreEqual(od1.ObtenerDateTime("atributoDateTime").Minute, od2.ObtenerDateTime("atributoDateTime").Minute);
            Assert.AreEqual(od1.ObtenerDateTime("atributoDateTime").Second, od2.ObtenerDateTime("atributoDateTime").Second);
            Assert.AreEqual(od1.ObtenerDecimal("atributoDecimal"), od2.ObtenerDecimal("atributoDecimal"));
            Assert.AreEqual(od1.ObtenerDouble("atributoDouble"), od2.ObtenerDouble("atributoDouble"));
            Assert.AreEqual(od1.ObtenerFloat("atributoFloat"), od2.ObtenerFloat("atributoFloat"));
            Assert.AreEqual(od1.ObtenerInteger("atributoInteger"), od2.ObtenerInteger("atributoInteger"));
            Assert.AreEqual(od1.ObtenerLong("atributoLong"), od2.ObtenerLong("atributoLong"));
            Assert.AreEqual(od1.ObtenerSByte("atributoSByte"), od2.ObtenerSByte("atributoSByte"));
            Assert.AreEqual(od1.ObtenerShort("atributoShort"), od2.ObtenerShort("atributoShort"));
            Assert.AreEqual(od1.ObtenerString("atributoString"), od2.ObtenerString("atributoString"));
            Assert.AreEqual(od1.ObtenerUShort("atributoUShort"), od2.ObtenerUShort("atributoUShort"));
            Assert.AreEqual(od1.ObtenerUInteger("atributoUInteger"), od2.ObtenerUInteger("atributoUInteger"));
            Assert.AreEqual(od1.ObtenerULong("atributoULong"), od2.ObtenerULong("atributoULong"));

            Assert.AreEqual(od1.ObtenerObjetoDatos("ReferenciaObjetoDatos") != null, od2.ObtenerObjetoDatos("ReferenciaObjetoDatos") != null);
            Assert.AreEqual(od1.ObtenerColeccion("ReferenciaObjetoDatosItem").Longitud, od2.ObtenerColeccion("ReferenciaObjetoDatosItem").Longitud);

            if (od1.ObtenerObjetoDatos("ReferenciaObjetoDatos") != null && od2.ObtenerObjetoDatos("ReferenciaObjetoDatos") != null)
            {
                Comparar(od1.ObtenerObjetoDatos("ReferenciaObjetoDatos"), od2.ObtenerObjetoDatos("ReferenciaObjetoDatos"));
            }

            for (int i = 0; i < od1.ObtenerColeccion("ReferenciaObjetoDatosItem").Longitud; i++)
            {
                Comparar(od1.ObtenerColeccion("ReferenciaObjetoDatosItem")[i], od2.ObtenerColeccion("ReferenciaObjetoDatosItem")[i]);
            }



            // compracion tipo2
            if (od1.Tipo.ObtenerPropiedad("ReferenciaObjetoDatos2") == null)
            {
                return;
            }

            Assert.AreEqual(od1.ObtenerObjetoDatos("ReferenciaObjetoDatos2") != null, od2.ObtenerObjetoDatos("ReferenciaObjetoDatos2") != null);

            if (od1.ObtenerObjetoDatos("ReferenciaObjetoDatos2") != null && od2.ObtenerObjetoDatos("ReferenciaObjetoDatos2") != null)
            {
                Comparar(od1.ObtenerObjetoDatos("ReferenciaObjetoDatos2"), od2.ObtenerObjetoDatos("ReferenciaObjetoDatos2"));
            }



            // comparacion tipo 3
            if (od1.Tipo.ObtenerPropiedad("ReferenciaObjetoDatosItem2") == null)
            {
                return;
            }

            Assert.AreEqual(od1.ObtenerObjetoDatos("ReferenciaObjetoDatosItem2") != null, od2.ObtenerObjetoDatos("ReferenciaObjetoDatosItem2") != null);

            if (od1.ObtenerObjetoDatos("ReferenciaObjetoDatosItem2") != null)
            {
                Assert.AreEqual(od1.ObtenerObjetoDatos("ReferenciaObjetoDatosItem2"), od1.ObtenerObjetoDatos("ReferenciaObjetoDatosItem[0]"));
                Assert.AreEqual(od2.ObtenerObjetoDatos("ReferenciaObjetoDatosItem2"), od2.ObtenerObjetoDatos("ReferenciaObjetoDatosItem[0]"));
            }
        }