Ejemplo n.º 1
0
        public ActionResult Test()
        {
            double random = -100000.0;
            double m      = -999.0;

            lib();
            WrapperTest w = new WrapperTest();

            try
            {
                // La fonction appelée en C++ Natif, via la librairie PNL,
                // tire un nombre tiré aléatoirement selon une loi normale centrée réduite,
                random = w.testWrapper(m);
            }
            catch (Exception ex)
            {
                System.Diagnostics.Debug.WriteLine(ex);
                ViewData["Exception"] = ex;
                return(View("Error"));
            }

            ViewData["Random"] = random;
            String dataChart = "[[1268179200000, 32.12],[1268265600000, 32.21],[1488326400000, 139.79],[1488412800000, 138.96],[1488499200000, 139.78],[1488758400000, 139.34],[1488844800000, 139.52]]";

            ViewData["dataChart"] = dataChart;
            return(View("Test"));
        }
Ejemplo n.º 2
0
 private void RunSimpleIntTest(Func <ISimpleInt, int, int, int> body, string result)
 {
     AssertException(() =>
     {
         var sut = new WrapperTest <ISimpleInt>(i => new LambdaWrapper(i, body));
         sut.AssertAllMethodsForward();
     }, result);
 }
Ejemplo n.º 3
0
        public TestService(WrapperTest wrap)
        {
            wrapper = wrap;
            var config = new MapperConfiguration(x =>
            {
                x.CreateMap <TestDTO, Test>();
                x.CreateMap <Test, TestDTO>();
            });

            mapper = config.CreateMapper();
        }
        public void PrimitiveWrapper_CompareToOtherTypeObject_ShouldBeNotEqual()
        {
            // Arrange
            var    first  = new WrapperTest(1);
            object second = "toto";

            // Act
            var areEqual = first.Equals(second);

            // Assert
            areEqual.Should().BeFalse();
        }
        public void PrimitiveWrapper_CompareToSameObject_ShouldBeEqual()
        {
            // Arrange
            var    first  = new WrapperTest(1);
            object second = first;

            // Act
            var areEqual = first.Equals(second);

            // Assert
            areEqual.Should().BeTrue();
        }
        public void PrimitiveWrapper_CompareToNotNullPrimitiveWrapper_ShouldNotBeEqual()
        {
            // Arrange
            WrapperTest first  = new WrapperTest(1);
            WrapperTest second = null;

            // Act
            var areEqual = first.Equals(second);

            // Assert
            areEqual.Should().BeFalse();
        }
Ejemplo n.º 7
0
        public void TestForwarding()
        {
            var tester = new WrapperTest <IFile>(target =>
            {
                var root = new Mock <IDirectory>();
                root.Setup(i => i.File("Test.txt")).Returns(target);
                return(new RelativeFile(() => root.Object, "Test.txt"));
            });

            tester.RegisterTypeCreator(() => new MemoryStream() as Stream);
            tester.AssertAllMethodsForward();
        }
        public void TwoPrimitiveWrapper_WithSameValues_HaveSameHashCode()
        {
            // Arrange
            var first  = new WrapperTest(1);
            var second = new WrapperTest(1);

            // Act
            var firstHashCode  = first.GetHashCode();
            var secondHashCode = second.GetHashCode();

            // Assert
            firstHashCode.Should().Be(secondHashCode);
        }
Ejemplo n.º 9
0
        public void GetWorks()
        {
            var sut = new WrapperTest <IWithProperties>(target =>
            {
                var m = new Mock <IWithProperties>();
                m.SetupGet(i => i.Out).Returns(() => target.Out);
                m.SetupGet(i => i.InOut).Returns(() => target.InOut);
                m.SetupSet(i => i.InOut = It.IsAny <int>()).Callback((int v) => target.InOut = v);
                m.SetupSet(i => i.In    = It.IsAny <int>()).Callback((int v) => target.In = v);
                return(m.Object);
            });

            sut.AssertAllMethodsForward();
        }
Ejemplo n.º 10
0
        public void SwapableStorePostSwao()
        {
            var initialStore = CreateBackedStore();
            var tester       = new WrapperTest <ITransactableStore>(i =>
            {
                var swapable = new SwapableStore(initialStore.Object);
                AsyncPump.Run(() => swapable.CopyAndTransferToNewStore(i));
                return(swapable);
            });

            tester.RegisterTypeCreator(() => new MockDirectory("c:\\a") as IDirectory);
            tester.AssertAllMethodsForward();

            initialStore.VerifyGet(i => i.UntransactedRoot, Times.Once);
            initialStore.VerifyNoOtherCalls();
        }
Ejemplo n.º 11
0
        public void TestRelativeDirectory()
        {
            var tester = new WrapperTest <MVVM.FileSystem.IDirectory>(target =>
            {
                var root = new Mock <IDirectory>();
                root.Setup(i => i.SubDirectory("Test.txt")).Returns(target);
                return(new RelativeDirectory(() => root.Object, "Test.txt"));
            });

            tester.RegisterTypeCreator(() => new MemoryStream() as Stream);
            tester.ExcludeMember(i => i.File(""));
            tester.ExcludeMember(i => i.SubDirectory(""));
            tester.ExcludeMember(i => i.AllFiles());
            tester.ExcludeMember(i => i.AllFiles("*.*"));
            tester.ExcludeMember(i => i.AllSubDirectories());
            tester.AssertAllMethodsForward();
        }
Ejemplo n.º 12
0
        public void WorkingExample()
        {
            var sut = new WrapperTest <ISimpleInt>(i => new LambdaWrapper(i, (target, a, b) => target.Swap(a, b)));

            sut.AssertAllMethodsForward();
        }