Exemplo n.º 1
0
        public async Task RemapWorkspaceEditAsync_RemapsEditsAsExpected()
        {
            // Arrange
            var expectedRange   = new TestRange(1, 1, 1, 5);
            var expectedVersion = 1;

            var requestInvoker = GetRequestInvoker(new[]
Exemplo n.º 2
0
        public string RunTest(
            string testFile,
            List <string> testsToRun,
            string resultLogFile,
            string errorLogFile,
            string failedConfFile,
            int numRetriesOnFailure,
            TestSuiteLoggerParams loggerParams,
            TestRange testRange,
            List <string> cliArgs,
            int testTimeout)
        {
            mLog.InfoFormat("Request to run tests on file [{0}]", testFile);

            if (mAutomatedLauncher != null)
            {
                string msg = "Can't launch another test suite because a test suite is currently running";
                mLog.Error(msg);
                return(msg);
            }

            mAutomatedLauncher = new PNUnitAutomatedLauncher(mListenAddress);

            return(mAutomatedLauncher.RunTest(
                       testFile,
                       testsToRun,
                       resultLogFile,
                       errorLogFile,
                       failedConfFile,
                       numRetriesOnFailure,
                       loggerParams,
                       testRange,
                       cliArgs == null ? null : cliArgs.ToArray(),
                       testTimeout));
        }
Exemplo n.º 3
0
        public void RunRangeChecks(TestRange[] testRanges, CheckValue[] checkValues)
        {
            uint       initialValue = testRanges[0].Value;
            const uint errorValue   = 0x0bad;

            var builder = new UnicodeTrieBuilder(initialValue, errorValue);

            for (int i = 1; i < testRanges.Length; i++)
            {
                TestRange r = testRanges[i];
                builder.SetRange(r.Start, r.End - 1, r.Value, r.Overwrite);
            }

            UnicodeTrie frozen = builder.Freeze();

            int cp = 0;

            for (int i = 0; i < checkValues.Length; i++)
            {
                CheckValue v = checkValues[i];

                while (cp < v.CodePoint)
                {
                    Assert.Equal(v.Value, builder.Get(cp));
                    Assert.Equal(v.Value, frozen.Get(cp));
                    cp++;
                }
            }
        }
Exemplo n.º 4
0
        private bool TestOutputRanges(out MccDaq.Range DefaultRange)
        {
            short dataValue = 0;

            MccDaq.ErrorInfo ULStat;
            MccDaq.Range     TestRange;
            bool             RangeFound = false;
            int    configVal;
            string ConnectionConflict;

            ConnectionConflict = "This network device is in use by another process or user." +
                                 System.Environment.NewLine + System.Environment.NewLine +
                                 "Check for other users on the network and close any applications " +
                                 System.Environment.NewLine +
                                 "(such as Instacal) that may be accessing the network device.";

            DefaultRange = MccDaq.Range.NotUsed;
            TestRange    = (MccDaq.Range)(-5);
            ULStat       = TestBoard.AOut(0, TestRange, dataValue);
            if (ULStat.Value == MccDaq.ErrorInfo.ErrorCode.NoErrors)
            {
                ULStat = TestBoard.GetConfig(2, 0, 114, out configVal);
                if (ULStat.Value == MccDaq.ErrorInfo.ErrorCode.NoErrors)
                {
                    DefaultRange = (MccDaq.Range)configVal;
                    RangeFound   = true;
                }
            }
            else
            {
                TestRange = MccDaq.Range.NotUsed;
                foreach (int i in Enum.GetValues(TestRange.GetType()))
                {
                    TestRange = (MccDaq.Range)i;
                    ULStat    = TestBoard.AOut(0, TestRange, dataValue);
                    if (ULStat.Value == MccDaq.ErrorInfo.ErrorCode.NoErrors)
                    {
                        if (DefaultRange == MccDaq.Range.NotUsed)
                        {
                            DefaultRange = TestRange;
                        }
                        RangeFound = true;
                        break;
                    }
                    else
                    {
                        if ((ULStat.Value == MccDaq.ErrorInfo.ErrorCode.NetDevInUseByAnotherProc) ||
                            (ULStat.Value == MccDaq.ErrorInfo.ErrorCode.NetDevInUse))
                        {
                            System.Windows.Forms.MessageBox.Show(ConnectionConflict, "Device In Use");
                            break;
                        }
                    }
                }
            }
            return(RangeFound);
        }
Exemplo n.º 5
0
        private bool TestInputRanges(out MccDaq.Range DefaultRange)
        {
            short dataValue;
            int   dataHRValue, Options, index;

            MccDaq.ErrorInfo ULStat;
            MccDaq.Range     TestRange;
            bool             RangeFound = false;
            string           ConnectionConflict;

            ConnectionConflict = "This network device is in use by another process or user." +
                                 System.Environment.NewLine + System.Environment.NewLine +
                                 "Check for other users on the network and close any applications " +
                                 System.Environment.NewLine +
                                 "(such as Instacal) that may be accessing the network device.";

            ValidRanges  = new MccDaq.Range[49];
            DefaultRange = MccDaq.Range.NotUsed;
            TestRange    = MccDaq.Range.NotUsed;
            Options      = 0;
            index        = 0;
            foreach (int i in Enum.GetValues(TestRange.GetType()))
            {
                TestRange = (MccDaq.Range)i;
                if (ADRes > 16)
                {
                    ULStat = TestBoard.AIn32(0, TestRange, out dataHRValue, Options);
                }
                else
                {
                    ULStat = TestBoard.AIn(0, TestRange, out dataValue);
                }
                if (ULStat.Value == MccDaq.ErrorInfo.ErrorCode.NoErrors)
                {
                    if (DefaultRange == MccDaq.Range.NotUsed)
                    {
                        DefaultRange = TestRange;
                    }
                    ValidRanges.SetValue(TestRange, index);
                    index      = index + 1;
                    RangeFound = true;
                }
                else
                {
                    if ((ULStat.Value == MccDaq.ErrorInfo.ErrorCode.NetDevInUseByAnotherProc) ||
                        (ULStat.Value == MccDaq.ErrorInfo.ErrorCode.NetDevInUse))
                    {
                        System.Windows.Forms.MessageBox.Show(ConnectionConflict, "Device In Use");
                        break;
                    }
                }
            }
            Array.Resize(ref ValidRanges, index);
            return(RangeFound);
        }
Exemplo n.º 6
0
        public void Maximum_Should_Be_Coerced_To_Minimum()
        {
            var target = new TestRange
            {
                Minimum = 100,
                Maximum = 50,
            };

            Assert.Equal(100, target.Minimum);
            Assert.Equal(100, target.Maximum);
        }
Exemplo n.º 7
0
        public void Maximum_Should_Be_Coerced_To_Minimum()
        {
            var target = new TestRange
            {
                Minimum = 100,
                Maximum = 50,
            };

            Assert.Equal(100, target.Minimum);
            Assert.Equal(100, target.Maximum);
        }
Exemplo n.º 8
0
        public async Task RemapWorkspaceEditAsync_RemapsEditsAsExpected()
        {
            // Arrange
            var expectedRange       = new TestRange(1, 1, 1, 5);
            var expectedVersion     = 1;
            var lazyDocumentManager = new Lazy <LSPDocumentManager>(() => {
                var documentManager = new TestDocumentManager();
                documentManager.AddDocument(RazorFile, Mock.Of <LSPDocumentSnapshot>(d => d.Version == expectedVersion && d.Uri == RazorFile));
                return(documentManager);
            });

            var requestInvoker = GetRequestInvoker(new[]
Exemplo n.º 9
0
        public void Value_Should_Be_Coerced_To_Range()
        {
            var target = new TestRange
            {
                Minimum = 0,
                Maximum = 50,
                Value = 100,
            };

            Assert.Equal(0, target.Minimum);
            Assert.Equal(50, target.Maximum);
            Assert.Equal(50, target.Value);
        }
Exemplo n.º 10
0
        public void Value_Should_Be_Coerced_To_Range()
        {
            var target = new TestRange
            {
                Minimum = 0,
                Maximum = 50,
                Value   = 100,
            };

            Assert.Equal(0, target.Minimum);
            Assert.Equal(50, target.Maximum);
            Assert.Equal(50, target.Value);
        }
Exemplo n.º 11
0
        public void Properties_Should_Not_Accept_Nan_And_Inifinity()
        {
            var target = new TestRange();

            Assert.Throws <ArgumentException>(() => target.Minimum = double.NaN);
            Assert.Throws <ArgumentException>(() => target.Minimum = double.PositiveInfinity);
            Assert.Throws <ArgumentException>(() => target.Minimum = double.NegativeInfinity);
            Assert.Throws <ArgumentException>(() => target.Maximum = double.NaN);
            Assert.Throws <ArgumentException>(() => target.Maximum = double.PositiveInfinity);
            Assert.Throws <ArgumentException>(() => target.Maximum = double.NegativeInfinity);
            Assert.Throws <ArgumentException>(() => target.Value   = double.NaN);
            Assert.Throws <ArgumentException>(() => target.Value   = double.PositiveInfinity);
            Assert.Throws <ArgumentException>(() => target.Value   = double.NegativeInfinity);
        }
Exemplo n.º 12
0
        public void Properties_Should_Not_Accept_Nan_And_Inifinity()
        {
            var target = new TestRange();

            Assert.Throws<ArgumentException>(() => target.Minimum = double.NaN);
            Assert.Throws<ArgumentException>(() => target.Minimum = double.PositiveInfinity);
            Assert.Throws<ArgumentException>(() => target.Minimum = double.NegativeInfinity);
            Assert.Throws<ArgumentException>(() => target.Maximum = double.NaN);
            Assert.Throws<ArgumentException>(() => target.Maximum = double.PositiveInfinity);
            Assert.Throws<ArgumentException>(() => target.Maximum = double.NegativeInfinity);
            Assert.Throws<ArgumentException>(() => target.Value = double.NaN);
            Assert.Throws<ArgumentException>(() => target.Value = double.PositiveInfinity);
            Assert.Throws<ArgumentException>(() => target.Value = double.NegativeInfinity);
        }
Exemplo n.º 13
0
        public void Coercion_Should_Be_Done_After_Initialization()
        {
            var target = new TestRange();

            target.BeginInit();

            var root = new TestRoot(target);

            target.Minimum = 1;

            target.EndInit();

            Assert.Equal(1, target.Value);
        }
Exemplo n.º 14
0
        public void Changing_Maximum_Should_Coerce_Value()
        {
            var target = new TestRange
            {
                Minimum = 0,
                Maximum = 100,
                Value   = 100,
            };

            target.Maximum = 50;

            Assert.Equal(0, target.Minimum);
            Assert.Equal(50, target.Maximum);
            Assert.Equal(50, target.Value);
        }
Exemplo n.º 15
0
        public void Changing_Maximum_Should_Coerce_Value()
        {
            var target = new TestRange
            {
                Minimum = 0,
                Maximum = 100,
                Value = 100,
            };

            target.Maximum = 50;

            Assert.Equal(0, target.Minimum);
            Assert.Equal(50, target.Maximum);
            Assert.Equal(50, target.Value);
        }
Exemplo n.º 16
0
        public void Changing_Minimum_Should_Coerce_Value_And_Maximum()
        {
            var target = new TestRange
            {
                Minimum = 0,
                Maximum = 100,
                Value   = 50,
            };
            var root = new TestRoot(target);

            target.Minimum = 200;

            Assert.Equal(200, target.Minimum);
            Assert.Equal(200, target.Maximum);
            Assert.Equal(200, target.Value);
        }
Exemplo n.º 17
0
        public void Coercion_Should_Not_Be_Done_During_Initialization()
        {
            var target = new TestRange();

            target.BeginInit();

            var root = new TestRoot(target);

            target.Minimum = 1;
            Assert.Equal(0, target.Value);

            target.Value = 50;
            target.EndInit();

            Assert.Equal(50, target.Value);
        }
Exemplo n.º 18
0
    static void Main(string[] args)
    {
        IEnumerable <IRange <int> >        enumRange1 = new IRange <int> [0];
        IEnumerable <IRange <int, float> > enumRange2 = new IRange <int, float> [0];

        IEnumerable <IRange <int, float, string> > enumRange3 = new TestRange <int, float, string>[]
        {
            new TestRange <int, float, string> {
                Begin = 10, End = 20, Data = 3.0F, MoreData = "Hello"
            },
            new TestRange <int, float, string> {
                Begin = 5, End = 30, Data = 3.0F, MoreData = "There!"
            }
        };

        enumRange1.RangeExtensions().Slice();
        enumRange2.RangeExtensions().Slice();
        enumRange3.RangeExtensions().Slice();
    }
        private bool TestOutputRanges(out MccDaq.Range DefaultRange)
        {
            short dataValue = 0;

            MccDaq.ErrorInfo ULStat;
            MccDaq.Range     TestRange;
            bool             RangeFound = false;
            int configVal;

            DefaultRange = MccDaq.Range.NotUsed;
            TestRange    = (MccDaq.Range)(-5);
            ULStat       = TestBoard.AOut(0, TestRange, dataValue);
            if (ULStat.Value == MccDaq.ErrorInfo.ErrorCode.NoErrors)
            {
                ULStat = TestBoard.GetConfig(2, 0, 114, out configVal);
                if (ULStat.Value == MccDaq.ErrorInfo.ErrorCode.NoErrors)
                {
                    DefaultRange = (MccDaq.Range)configVal;
                    RangeFound   = true;
                }
            }
            else
            {
                TestRange = MccDaq.Range.NotUsed;
                foreach (int i in Enum.GetValues(TestRange.GetType()))
                {
                    TestRange = (MccDaq.Range)i;
                    ULStat    = TestBoard.AOut(0, TestRange, dataValue);
                    if (ULStat.Value == MccDaq.ErrorInfo.ErrorCode.NoErrors)
                    {
                        if (DefaultRange == MccDaq.Range.NotUsed)
                        {
                            DefaultRange = TestRange;
                        }
                        RangeFound = true;
                        break;
                    }
                }
            }
            return(RangeFound);
        }
        private bool TestInputRanges(out MccDaq.Range DefaultRange)
        {
            short dataValue;
            int   dataHRValue, Options, index;

            MccDaq.ErrorInfo ULStat;
            MccDaq.Range     TestRange;
            bool             RangeFound = false;

            ValidRanges  = new MccDaq.Range[49];
            DefaultRange = MccDaq.Range.NotUsed;
            TestRange    = MccDaq.Range.NotUsed;
            Options      = 0;
            index        = 0;
            foreach (int i in Enum.GetValues(TestRange.GetType()))
            {
                TestRange = (MccDaq.Range)i;
                if (ADRes > 16)
                {
                    ULStat = TestBoard.AIn32(0, TestRange, out dataHRValue, Options);
                }
                else
                {
                    ULStat = TestBoard.AIn(0, TestRange, out dataValue);
                }
                if (ULStat.Value == MccDaq.ErrorInfo.ErrorCode.NoErrors)
                {
                    if (DefaultRange == MccDaq.Range.NotUsed)
                    {
                        DefaultRange = TestRange;
                    }
                    ValidRanges.SetValue(TestRange, index);
                    index      = index + 1;
                    RangeFound = true;
                }
            }
            Array.Resize(ref ValidRanges, index);
            return(RangeFound);
        }
Exemplo n.º 21
0
        public void SetValue_Should_Not_Cause_StackOverflow(bool useXamlBinding)
        {
            var viewModel = new TestStackOverflowViewModel()
            {
                Value = 50
            };

            Track track = null;

            var target = new TestRange()
            {
                Template = new FuncControlTemplate <RangeBase>(c =>
                {
                    track = new Track()
                    {
                        Width       = 100,
                        Orientation = Orientation.Horizontal,
                        [~~Track.MinimumProperty] = c[~~RangeBase.MinimumProperty],
                        [~~Track.MaximumProperty] = c[~~RangeBase.MaximumProperty],

                        Name  = "PART_Track",
                        Thumb = new Thumb()
                    };

                    if (useXamlBinding)
                    {
                        track.Bind(Track.ValueProperty, new Binding("Value")
                        {
                            Mode     = BindingMode.TwoWay,
                            Source   = c,
                            Priority = BindingPriority.Style
                        });
                    }
                    else
                    {
                        track[~~Track.ValueProperty] = c[~~RangeBase.ValueProperty];
                    }

                    return(track);
                }),
                Minimum     = 0,
                Maximum     = 100,
                DataContext = viewModel
            };

            target.Bind(TestRange.ValueProperty, new Binding("Value")
            {
                Mode = BindingMode.TwoWay
            });

            target.ApplyTemplate();
            track.Measure(new Size(100, 0));
            track.Arrange(new Rect(0, 0, 100, 0));

            Assert.Equal(1, viewModel.SetterInvokedCount);

            // Issues #855 and #824 were causing a StackOverflowException at this point.
            target.Value = 51.001;

            Assert.Equal(2, viewModel.SetterInvokedCount);

            double expected = 51;

            Assert.Equal(expected, viewModel.Value);
            Assert.Equal(expected, target.Value);
            Assert.Equal(expected, track.Value);
        }
Exemplo n.º 22
0
        internal string RunTest(
            string testFile,
            List <string> testsToRun,
            string resultLogFile,
            string errorLogFile,
            string failedConfFile,
            int numRetriesOnFailure,
            TestSuiteLoggerParams loggerParams,
            TestRange testRange,
            string[] cliArgs,
            int testTimeout)
        {
            mLoggerParams = loggerParams;

            try
            {
                mGroup = TestConfLoader.LoadFromFile(testFile, cliArgs);

                if ((mGroup == null) || (mGroup.ParallelTests.Count == 0))
                {
                    mLog.WarnFormat("[{0}] no tests to run", testFile);
                    return("No tests to run");
                }

                mTestsList = testsToRun;

                if (testRange == null)
                {
                    testRange = new TestRange(0, mGroup.ParallelTests.Count - 1);
                }

                if (testRange.EndTest >= mGroup.ParallelTests.Count)
                {
                    testRange.EndTest = mGroup.ParallelTests.Count - 1;
                }

                mUserValues = CliArgsReader.GetUserValues(cliArgs);

                mLauncherArgs = new LauncherArgs();

                mLauncherArgs.ResultLogFile    = resultLogFile;
                mLauncherArgs.ErrorLogFile     = errorLogFile;
                mLauncherArgs.FailedConfigFile = failedConfFile;
                mLauncherArgs.RetryOnFailure   = numRetriesOnFailure;
                mLauncherArgs.MaxRetry         = numRetriesOnFailure;
                mLauncherArgs.TestRange        = testRange;
                mLauncherArgs.TestsTimeout     = testTimeout;

                System.Threading.ThreadPool.QueueUserWorkItem(
                    new System.Threading.WaitCallback(Run));

                return(string.Format(
                           "Trying to launch {0} tests",
                           mGroup.ParallelTests.Count));
            }
            catch (Exception e)
            {
                mLog.ErrorFormat("RunTest error {0}", e.Message);
                mLog.Debug(e.StackTrace);
                return(e.Message);
            }
        }