Exemplo n.º 1
0
        public void AddEdge03()
        {
            AdjacencyGraph        adjacencyGraph;
            VertexAndEdgeProvider s0 = new VertexAndEdgeProvider();

            adjacencyGraph = AdjacencyGraphFactory.CreateAcyclicGraph(s0, true, 0);
            ((GenericMutableGraphTestNEW)this).AddEdge(adjacencyGraph);
            PexAssert.IsNotNull((object)adjacencyGraph);
            PexAssert.AreEqual <bool>(true, adjacencyGraph.IsDirected);
            PexAssert.IsNotNull(adjacencyGraph.Provider);
            PexAssert.IsNotNull(adjacencyGraph.Edges);
        }
Exemplo n.º 2
0
        public void RemoveSettings()
        {
            storage.SaveSetting("X", 5);
            storage.SaveSetting("NAME", "Charlie");

            storage.RemoveSetting("X");
            PexAssert.IsNull(storage.GetSetting("X"), "X not removed");
            PexAssert.AreEqual("Charlie", storage.GetSetting("NAME"));

            storage.RemoveSetting("NAME");
            PexAssert.IsNull(storage.GetSetting("NAME"), "NAME not removed");
        }
Exemplo n.º 3
0
        public void TraversalPUT16()
        {
            List <int> list;

            int[] ints = new int[2];
            ints[0] = 1;
            list    = new List <int>((IEnumerable <int>)ints);
            this.TraversalPUT(list);
            PexAssert.IsNotNull((object)list);
            PexAssert.AreEqual <int>(2, list.Capacity);
            PexAssert.AreEqual <int>(2, list.Count);
        }
Exemplo n.º 4
0
 public void InsertAndCurrentAndModify <TPriority, TValue>(
     [PexAssumeUnderTest] BinaryHeap <TPriority, TValue> target,
     KeyValuePair <TPriority, TValue> kv)
 {
     target.Add(kv.Key, kv.Value);
     PexAssert.Throws <InvalidOperationException>(delegate
     {
         var enumerator = target.GetEnumerator();
         target.Add(kv.Key, kv.Value);
         var current = enumerator.Current;
     });
 }
Exemplo n.º 5
0
        public void EdgeCapacityGetSet <TVertex, TEdge>(
            [PexAssumeUnderTest] AdjacencyGraph <TVertex, TEdge> target,
            int value
            )
            where TEdge : IEdge <TVertex>
        {
            // TODO: add assertions to method AdjacencyGraphTVertexTEdgeTest.EdgeCapacityGetSet(AdjacencyGraph`2<!!0,!!1>)
            target.EdgeCapacity = value;
            int result = target.EdgeCapacity;

            PexAssert.AreEqual((object)value, (object)result);
        }
Exemplo n.º 6
0
        public void IterationPUT03()
        {
            AdjacencyGraph        adjacencyGraph;
            VertexAndEdgeProvider s0 = new VertexAndEdgeProvider();

            adjacencyGraph = AdjacencyGraphFactory.CreateCyclicGraph(s0, false, 0);
            ((GenericVertexListGraphTest)this).IterationPUT(adjacencyGraph);
            PexAssert.IsNotNull((object)adjacencyGraph);
            PexAssert.AreEqual <bool>(true, adjacencyGraph.IsDirected);
            PexAssert.IsNotNull(adjacencyGraph.Provider);
            PexAssert.IsNotNull(adjacencyGraph.Edges);
        }
Exemplo n.º 7
0
 public void WoodFunction(double x1, double x2, double x3, double x4)
 {
     if ((10 * (x2 - x1 * x1)) == 0 &&
         (1 - x1) == 0 &&
         (Math.Sqrt(90) * (x4 - x3 * x3)) == 0 &&
         (1 - x3) == 0 &&
         (Math.Sqrt(10) * (x2 + x4 - 2)) == 0 &&
         (Math.Pow(10, -0.5) * (x2 - x4)) == 0)
     {
         PexAssert.ReachEventually();
     }
 }
Exemplo n.º 8
0
 public void IsAssemblyFileTypePUT1([PexAssumeUnderTest] String inpPath)
 {
     //PexAssume.IsFalse(inpPath.Contains("\0"));
     if (inpPath.EndsWith(".dll") || inpPath.EndsWith(".exe"))
     {
         PexAssert.IsTrue(PathUtils.IsAssemblyFileType(inpPath));
     }
     else
     {
         PexAssert.IsFalse(PathUtils.IsAssemblyFileType(inpPath));
     }
 }
Exemplo n.º 9
0
        public void InsertionMassivePUT18()
        {
            List <int> list;

            int[] ints = new int[2];
            ints[0] = 1;
            list    = new List <int>((IEnumerable <int>)ints);
            this.InsertionMassivePUT(list);
            PexAssert.IsNotNull((object)list);
            PexAssert.AreEqual <int>(2, list.Capacity);
            PexAssert.AreEqual <int>(2, list.Count);
        }
Exemplo n.º 10
0
        public void ClearVertexTargetSource04()
        {
            AdjacencyGraph        adjacencyGraph;
            VertexAndEdgeProvider s0 = new VertexAndEdgeProvider();

            adjacencyGraph = AdjacencyGraphFactory.CreateCyclicGraph(s0, false, 0);
            ((GenericMutableGraphTestNEW)this).ClearVertexTargetSource(adjacencyGraph);
            PexAssert.IsNotNull((object)adjacencyGraph);
            PexAssert.AreEqual <bool>(true, adjacencyGraph.IsDirected);
            PexAssert.IsNotNull(adjacencyGraph.Provider);
            PexAssert.IsNotNull(adjacencyGraph.Edges);
        }
 public void Test_ExtractAll<T>([PexAssumeNotNull] T[] array, T item) where T : IComparable<T> {
     var seq = OrderedSequence.FromEnumerable(array);
     var split = seq.ExtractAll(item);
     Assert2.SequenceEqual(seq, split.Item1.Concat(split.Item2).Concat(split.Item3));
     PexAssert.TrueForAll(split.Item1, t => t.CompareTo(item) < 0);
     PexAssert.TrueForAll(split.Item2, t => t.CompareTo(item) == 0);
     PexAssert.TrueForAll(split.Item3, t => t.CompareTo(item) > 0);
     Assert2.SequenceEqual(split.Item1, seq.LessThan(item));
     Assert2.SequenceEqual(split.Item1.Concat(split.Item2), seq.AtMost(item));
     Assert2.SequenceEqual(split.Item2.Concat(split.Item3), seq.AtLeast(item));
     Assert2.SequenceEqual(split.Item3, seq.GreaterThan(item));
 }
Exemplo n.º 12
0
        public void ClearVertexTargetSource03()
        {
            AdjacencyGraph        adjacencyGraph;
            VertexAndEdgeProvider s0 = new VertexAndEdgeProvider();

            adjacencyGraph = AdjacencyGraphFactory.CreateAcyclicGraph(s0, false, 16);
            this.ClearVertexTargetSource(adjacencyGraph);
            PexAssert.IsNotNull((object)adjacencyGraph);
            PexAssert.AreEqual <bool>(true, adjacencyGraph.IsDirected);
            PexAssert.IsNotNull(adjacencyGraph.Provider);
            PexAssert.IsNotNull(adjacencyGraph.Edges);
        }
Exemplo n.º 13
0
        public void ContainsTest14()
        {
            List <int> list;

            int[] ints = new int[1];
            ints[0] = 1073741824;
            list    = new List <int>((IEnumerable <int>)ints);
            this.ContainsTest(list, 1);
            PexAssert.IsNotNull((object)list);
            PexAssert.AreEqual <int>(1, list.Capacity);
            PexAssert.AreEqual <int>(1, list.Count);
        }
Exemplo n.º 14
0
        public void Return <T>(T value)
        {
            var count      = 0;
            var enumerable = EnumerableEx.Return(value);

            foreach (var res in enumerable)
            {
                count++;
                PexAssert.AreEqual(value, res);
            }
            PexAssert.AreEqual(1, count);
        }
Exemplo n.º 15
0
        public void CatchDoCatch <T>([PexAssumeNotNull] IEnumerable <T> begin, [PexAssumeNotNull] IEnumerable <T> rest, [PexAssumeNotNull] IEnumerable <T> alternative, bool shouldThrow)
        {
            var ex = new InvalidOperationException();
            var expectedCaughtCount = shouldThrow ? 1 : 0;
            var caughtCount         = 0;
            Func <Exception, IEnumerable <T> > replacer = x =>
            {
                caughtCount++;
                PexAssert.AreEqual(ex, x);
                return(alternative);
            };

            var start = begin;

            if (shouldThrow)
            {
                start = start.Concat(EnumerableEx.Throw <T>(ex));
            }
            start = start.Concat(rest);
            var enumerable = start.Catch(replacer);
            var enumerator = enumerable.GetEnumerator();

            var beginEnumerator = begin.GetEnumerator();

            while (beginEnumerator.MoveNext())
            {
                PexAssert.IsTrue(enumerator.MoveNext());
                PexAssert.AreEqual(beginEnumerator.Current, enumerator.Current);
            }

            if (shouldThrow)
            {
                var alternativeEnumerator = alternative.GetEnumerator();
                while (alternativeEnumerator.MoveNext())
                {
                    PexAssert.IsTrue(enumerator.MoveNext());
                    PexAssert.AreEqual(alternativeEnumerator.Current, enumerator.Current);
                }
            }
            else
            {
                var restEnumerator = rest.GetEnumerator();
                while (restEnumerator.MoveNext())
                {
                    PexAssert.IsTrue(enumerator.MoveNext());
                    PexAssert.AreEqual(restEnumerator.Current, enumerator.Current);
                }
            }
            PexAssert.IsFalse(enumerator.MoveNext());

            PexAssert.AreEqual(expectedCaughtCount, caughtCount);
        }
Exemplo n.º 16
0
 public void NoScript_AnyInput(ErrorMode errorMode, [PexAssumeNotNull] string input)
 {
     PexAssume.EnumIsDefined(errorMode);
     try
     {
         var output = BBEncodeForTest(input, errorMode);
         PexAssert.IsTrue(!output.Contains("<script"));
     }
     catch (BBCodeParsingException)
     {
         PexAssume.Fail();
     }
 }
Exemplo n.º 17
0
        public void BadSettingPUT1([PexAssumeUnderTest] SettingsGroup testGroup1, [PexAssumeUnderTest] String settingName, [PexAssumeNotNull] Object settingValue, int defSettingValue)
        {
            PexAssume.IsTrue(settingName != null);
            PexAssume.IsTrue(settingValue != null);
            //PexAssume.IsTrue(defSettingValue != null);
            PexAssume.IsTrue(settingValue is string);
            String str_sv = settingValue as string;

            PexAssume.IsTrue(Regex.IsMatch(str_sv, "@([a-z])*"));

            testGroup1.SaveSetting(settingName, settingValue);
            PexAssert.AreEqual(defSettingValue, testGroup1.GetSetting(settingName, defSettingValue));
        }
Exemplo n.º 18
0
        /// Summary
        /// Time: 1 min 45 sec
        /// Pattern: AAAA, Commutative Diagram, AllowedException
        /// Generalizes two tests "FindMaxTest, FindMaxTreeEmptyTest" into one PUT
        public void FindMaxTest([PexAssumeUnderTest] int[] elements)
        {
            BinarySearchTree <int> bst = new BinarySearchTree <int>(elements);
            //Compute the maximum element
            int maxValue = Int32.MinValue;

            foreach (int val in elements)
            {
                maxValue = maxValue < val ? val : maxValue;
            }

            PexAssert.AreEqual(maxValue, bst.FindMax());
        }
Exemplo n.º 19
0
        public void ClearPUT21()
        {
            List <int> list;

            int[] ints = new int[3];
            ints[0] = 1;
            ints[2] = 16384;
            list    = new List <int>((IEnumerable <int>)ints);
            this.ClearPUT(list);
            PexAssert.IsNotNull((object)list);
            PexAssert.AreEqual <int>(3, list.Capacity);
            PexAssert.AreEqual <int>(3, list.Count);
        }
        public void Add_SeveralValues_CountIsIncrementedByCountOfNewValues440()
        {
            BinaryHeap <int, int> binaryHeap;

            binaryHeap = BinaryHeapFactory.Create();
            KeyValuePair <int, int>[] keyValuePairs = new KeyValuePair <int, int> [1];
            KeyValuePair <int, int>   s0            = new KeyValuePair <int, int>(1, default(int));

            keyValuePairs[0] = s0;
            this.Add_SeveralValues_CountIsIncrementedByCountOfNewValues <int, int>
                (binaryHeap, keyValuePairs);
            PexAssert.IsNotNull((object)binaryHeap);
        }
Exemplo n.º 21
0
        public void RemoveTreePUT26()
        {
            List <int> list;

            int[] ints = new int[3];
            ints[0] = 3;
            ints[1] = 1;
            list    = new List <int>((IEnumerable <int>)ints);
            this.RemoveTreePUT(list, 0, 0);
            PexAssert.IsNotNull((object)list);
            PexAssert.AreEqual <int>(3, list.Capacity);
            PexAssert.AreEqual <int>(3, list.Count);
        }
        public void FindParentNoItemsInBstTest18()
        {
            List <int> list;

            int[] ints = new int[2];
            ints[0] = 1048577;
            ints[1] = 1;
            list    = new List <int>((IEnumerable <int>)ints);
            this.FindParentNoItemsInBstTest(list, 0);
            PexAssert.IsNotNull((object)list);
            PexAssert.AreEqual <int>(2, list.Capacity);
            PexAssert.AreEqual <int>(2, list.Count);
        }
Exemplo n.º 23
0
        public void CanParseMultipleCategoriesWithAndPUT([PexAssumeUnderTest] CategoryExpression expr)
        {
            //CategoryExpression expr = new CategoryExpression("One + Two+Three");
            AndFilter andFilter = (AndFilter)expr.Filter;

            String[] tokens = expr.GetToken().Split('|');
            PexAssert.AreEqual(tokens.Length, andFilter.Filters.Length);
            for (int i = 0; i < andFilter.Filters.Length; i++)
            {
                CategoryFilter catFilter = (CategoryFilter)andFilter.Filters[i];
                PexAssert.AreEqual(catFilter.Categories, tokens[i]);
            }
        }
        public void GetEnumeratorTest15()
        {
            List <int> list;

            int[] ints = new int[4];
            ints[1] = int.MinValue;
            ints[3] = 1;
            list    = new List <int>((IEnumerable <int>)ints);
            this.GetEnumeratorTest(list);
            PexAssert.IsNotNull((object)list);
            PexAssert.AreEqual <int>(4, list.Capacity);
            PexAssert.AreEqual <int>(4, list.Count);
        }
Exemplo n.º 25
0
        public void OpenImageOk()
        {
            const string fn = "pMin.png";
            var          f  = new OpenImageToBitmap(fn);

            PexAssert.AreEqual(f.OpenImage().ToStr(),
                               new List <CPoint>()
            {
                new CPoint(0, 0), new CPoint(1, 1),
                new CPoint(12, 35), new CPoint(47, 29), new CPoint(51, 8),
                new CPoint(29, 17), new CPoint(81, 58)
            }.ToStr());
        }
Exemplo n.º 26
0
        public void RemoveOutEdgeIf04()
        {
            AdjacencyGraph        adjacencyGraph;
            VertexAndEdgeProvider s0 = new VertexAndEdgeProvider();

            adjacencyGraph = AdjacencyGraphFactory.CreateCyclicGraph
                                 (s0, PexSafeHelpers.ByteToBoolean((byte)2), 16);
            this.RemoveOutEdgeIf(adjacencyGraph);
            PexAssert.IsNotNull((object)adjacencyGraph);
            PexAssert.AreEqual <bool>(true, adjacencyGraph.IsDirected);
            PexAssert.IsNotNull(adjacencyGraph.Provider);
            PexAssert.IsNotNull(adjacencyGraph.Edges);
        }
Exemplo n.º 27
0
        public void FindNodeValidLeftChildTest19()
        {
            List <int> list;

            int[] ints = new int[2];
            ints[0] = 536870879;
            ints[1] = 788529119;
            list    = new List <int>((IEnumerable <int>)ints);
            this.FindNodeValidLeftChildTest(list, 0, 805306334);
            PexAssert.IsNotNull((object)list);
            PexAssert.AreEqual <int>(2, list.Capacity);
            PexAssert.AreEqual <int>(2, list.Count);
        }
        public void RemoveOutEdgeIf01()
        {
            AdjacencyGraph        adjacencyGraph;
            VertexAndEdgeProvider s0 = new VertexAndEdgeProvider();

            adjacencyGraph = AdjacencyGraphFactory.CreateAcyclicGraph
                                 (s0, PexSafeHelpers.ByteToBoolean((byte)4), 49);
            ((GenericMutableAdjacencyGraphTest)this).RemoveOutEdgeIf(adjacencyGraph);
            PexAssert.IsNotNull((object)adjacencyGraph);
            PexAssert.AreEqual <bool>(true, adjacencyGraph.IsDirected);
            PexAssert.IsNotNull(adjacencyGraph.Provider);
            PexAssert.IsNotNull(adjacencyGraph.Edges);
        }
Exemplo n.º 29
0
        public void InsertAndEnumerate <TPriority, TValue>(
            [PexAssumeUnderTest] BinaryHeap <TPriority, TValue> target,
            [PexAssumeNotNull] KeyValuePair <TPriority, TValue>[] kvs)
        {
            var dic = new Dictionary <TPriority, TValue>();

            foreach (var kv in kvs)
            {
                target.Add(kv.Key, kv.Value);
                dic[kv.Key] = kv.Value;
            }
            PexAssert.TrueForAll(target, kv => dic.ContainsKey(kv.Key));
        }
Exemplo n.º 30
0
        public void FindNodeValidLeftChildTest18()
        {
            List <int> list;

            int[] ints = new int[2];
            ints[0] = 131073;
            ints[1] = 1;
            list    = new List <int>((IEnumerable <int>)ints);
            this.FindNodeValidLeftChildTest(list, 0, 0);
            PexAssert.IsNotNull((object)list);
            PexAssert.AreEqual <int>(2, list.Capacity);
            PexAssert.AreEqual <int>(2, list.Count);
        }