public void PositiveGenericAbstractClassWithContract3()
        {
            GenericAbstractClass <string, string> a = new ImplForGenericAbstractClass();
            var result = a.FirstNonNullMatch(new[] { null, null, "a", "b" });

            Assert.AreEqual("a", result);
        }
        public void PositiveGenericAbstractClassWithContract7()
        {
            GenericAbstractClass <string, string> a = new ImplForGenericAbstractClass();
            var result = a.GenericMethod <object>(new[] { "a", "b" });

            Assert.AreEqual(2, result.Length);
        }
        public void PositiveGenericAbstractClassWithContract5()
        {
            GenericAbstractClass <string, string> a = new ImplForGenericAbstractClass();
            var result = a.GenericMethod <float>(new[] { null, null, "a", "b" });

            Assert.AreEqual(0, result.Length);
        }
        public void PositiveGenericAbstractClassWithContract2()
        {
            GenericAbstractClass <string, string> a = new ImplForGenericAbstractClass();
            var result = a.Collection(2, 3);

            Assert.AreEqual(2, result.Length);
        }
        public void NegativeGenericAbstractClassWithContract7()
        {
            GenericAbstractClass <string, string> a = new ImplForGenericAbstractClass();

            Assert.Throws <TestRewriterMethods.PostconditionException>(
                () =>
            {
                var result = a.GenericMethod <int>(new string[0]);
            });
        }
        public void NegativeGenericAbstractClassWithContract3()
        {
            GenericAbstractClass <string, string> a = new ImplForGenericAbstractClass();

            Assert.Throws <TestRewriterMethods.PostconditionException>(() => a.ReturnFirst(new[] { "3", "4", "5" }, "", false));
        }
 public void NegativeGenericAbstractClassWithContract3()
 {
   GenericAbstractClass<string, string> a = new ImplForGenericAbstractClass();
   Assert.Throws<TestRewriterMethods.PostconditionException>(() => a.ReturnFirst(new[] { "3", "4", "5" }, "", false));
 }
 public void NegativeGenericAbstractClassWithContract6()
 {
     GenericAbstractClass <string, string> a = new ImplForGenericAbstractClass();
     var result = a.GenericMethod <string>(null);
 }
        public void NegativeGenericAbstractClassWithContract4()
        {
            GenericAbstractClass <string, string> a = new ImplForGenericAbstractClass();

            a.Collection(5, 5);
        }
 public void NegativeGenericAbstractClassWithContract5()
 {
   GenericAbstractClass<string, string> a = new ImplForGenericAbstractClass();
   Assert.Throws<TestRewriterMethods.PostconditionException>(() => a.FirstNonNullMatch(new string[] { null, null, null }));
 }
 public void NegativeGenericAbstractClassWithContract2()
 {
   GenericAbstractClass<string, string> a = new ImplForGenericAbstractClass();
   a.ReturnFirst(new string[] { }, null, true);
 }
 public void PositiveGenericAbstractClassWithContract7()
 {
   GenericAbstractClass<string, string> a = new ImplForGenericAbstractClass();
   var result = a.GenericMethod<object>(new[] { "a", "b" });
   Assert.AreEqual(2, result.Length);
 }
 public void PositiveGenericAbstractClassWithContract5()
 {
   GenericAbstractClass<string, string> a = new ImplForGenericAbstractClass();
   var result = a.GenericMethod<float>(new[] { null, null, "a", "b" });
   Assert.AreEqual(0, result.Length);
 }
 public void PositiveGenericAbstractClassWithContract3()
 {
   GenericAbstractClass<string, string> a = new ImplForGenericAbstractClass();
   var result = a.FirstNonNullMatch(new[] { null, null, "a", "b" });
   Assert.AreEqual("a", result);
 }
 public void PositiveGenericAbstractClassWithContract2()
 {
   GenericAbstractClass<string, string> a = new ImplForGenericAbstractClass();
   var result = a.Collection(2, 3);
   Assert.AreEqual(2, result.Length);
 }
 public void PositiveGenericAbstractClassWithContract()
 {
   GenericAbstractClass<string, string> a = new ImplForGenericAbstractClass();
   a.ReturnFirst(new[] { "a", "B", "c" }, "B", true);
 }
 public void NegativeGenericAbstractClassWithContract7()
 {
   GenericAbstractClass<string, string> a = new ImplForGenericAbstractClass();
   Assert.Throws<TestRewriterMethods.PostconditionException>(
     () =>
     {
       var result = a.GenericMethod<int>(new string[0]);
     });
 }
        public void NegativeGenericAbstractClassWithContract4()
        {
            GenericAbstractClass <string, string> a = new ImplForGenericAbstractClass();

            Assert.Throws <TestRewriterMethods.PostconditionException>(() => a.Collection(5, 5));
        }
        public void NegativeGenericAbstractClassWithContract5()
        {
            GenericAbstractClass <string, string> a = new ImplForGenericAbstractClass();

            Assert.Throws <TestRewriterMethods.PostconditionException>(() => a.FirstNonNullMatch(new string[] { null, null, null }));
        }
 public void NegativeGenericAbstractClassWithContract3()
 {
   GenericAbstractClass<string, string> a = new ImplForGenericAbstractClass();
   a.ReturnFirst(new[] { "3", "4", "5" }, "", false);
 }
        public void PositiveGenericAbstractClassWithContract()
        {
            GenericAbstractClass <string, string> a = new ImplForGenericAbstractClass();

            a.ReturnFirst(new[] { "a", "B", "c" }, "B", true);
        }
        public void NegativeGenericAbstractClassWithContract2()
        {
            GenericAbstractClass <string, string> a = new ImplForGenericAbstractClass();

            a.ReturnFirst(new string[] { }, null, true);
        }
 public void NegativeGenericAbstractClassWithContract4()
 {
   GenericAbstractClass<string, string> a = new ImplForGenericAbstractClass();
   a.Collection(5, 5);
 }
 public void NegativeGenericAbstractClassWithContract4()
 {
   GenericAbstractClass<string, string> a = new ImplForGenericAbstractClass();
   Assert.Throws<TestRewriterMethods.PostconditionException>(() => a.Collection(5, 5));
 }
 public void NegativeGenericAbstractClassWithContract5()
 {
   GenericAbstractClass<string, string> a = new ImplForGenericAbstractClass();
   a.FirstNonNullMatch(new string[] { null, null, null });
 }
 public void NegativeGenericAbstractClassWithContract6()
 {
   GenericAbstractClass<string, string> a = new ImplForGenericAbstractClass();
   var result = a.GenericMethod<string>(null);
 }
        public void NegativeGenericAbstractClassWithContract3()
        {
            GenericAbstractClass <string, string> a = new ImplForGenericAbstractClass();

            a.ReturnFirst(new[] { "3", "4", "5" }, "", false);
        }
 public void NegativeGenericAbstractClassWithContract7()
 {
   GenericAbstractClass<string, string> a = new ImplForGenericAbstractClass();
   var result = a.GenericMethod<int>(new string[0]);
 }
        public void NegativeGenericAbstractClassWithContract5()
        {
            GenericAbstractClass <string, string> a = new ImplForGenericAbstractClass();

            a.FirstNonNullMatch(new string[] { null, null, null });
        }
        public void NegativeGenericAbstractClassWithContract2()
        {
            GenericAbstractClass <string, string> a = new ImplForGenericAbstractClass();

            Assert.Throws <TestRewriterMethods.PreconditionException>(() => a.ReturnFirst(new string[] { }, null, true));
        }
 public void NegativeGenericAbstractClassWithContract7()
 {
     GenericAbstractClass <string, string> a = new ImplForGenericAbstractClass();
     var result = a.GenericMethod <int>(new string[0]);
 }
 public void NegativeGenericAbstractClassWithContract2()
 {
   GenericAbstractClass<string, string> a = new ImplForGenericAbstractClass();
   Assert.Throws<TestRewriterMethods.PreconditionException>(() => a.ReturnFirst(new string[] { }, null, true));
 }