Removed second type parameter on conventions

Jake Ginnivan · Jake Ginnivan · commit ccc8237e0097 · 2013-08-10T08:42:43.000+01:00
diff --git a/TestStack.ConventionTests.Tests/ConventionAssertionClassTests.cs b/TestStack.ConventionTests.Tests/ConventionAssertionClassTests.cs
@@ -34,10 +34,10 @@ public ConventionReportFailure Format(string failingData)
             }
         }
 
-        public class FailingConvention : IConvention<FakeData, string>
+        public class FailingConvention : IConvention<FakeData>
         {
             public string ConventionTitle { get { return "Header"; } }
-            public IEnumerable<string> GetFailingData(FakeData data)
+            public IEnumerable<object> GetFailingData(FakeData data)
             {
                 return new[] {"Different"};
             }
diff --git a/TestStack.ConventionTests/Convention.cs b/TestStack.ConventionTests/Convention.cs
@@ -31,13 +31,13 @@ static Convention()
         public static IEnumerable<ResultInfo> ConventionReports { get { return Reports; } }
         public static IList<IReportDataFormatter> Formatters { get; private set; } 
 
-        public static void Is<TDataSource, TDataType>(IConvention<TDataSource, TDataType> convention, TDataSource data)
+        public static void Is<TDataSource>(IConvention<TDataSource> convention, TDataSource data)
             where TDataSource : IConventionData
         {
             Is(convention, data, new ConventionResultExceptionReporter());
         }
 
-        public static void Is<TDataSource, TDataType>(IConvention<TDataSource, TDataType> convention, TDataSource data, IConventionReportRenderer reporter) 
+        public static void Is<TDataSource>(IConvention<TDataSource> convention, TDataSource data, IConventionReportRenderer reporter) 
             where TDataSource : IConventionData
         {
             try
@@ -55,7 +55,7 @@ public static void Is<TDataSource, TDataType>(IConvention<TDataSource, TDataType
             }
         }
 
-        public static void IsWithApprovedExeptions<TDataSource, TDataType>(IConvention<TDataSource, TDataType> convention, TDataSource data)
+        public static void IsWithApprovedExeptions<TDataSource>(IConvention<TDataSource> convention, TDataSource data)
             where TDataSource : IConventionData
         {
             var conventionResult = GetConventionReport(convention.ConventionTitle, convention.GetFailingData(data).ToArray(), data);
@@ -82,13 +82,13 @@ public static void IsWithApprovedExeptions<TDataSource, TDataType>(IConvention<T
             }
         }
 
-        public static void Is<TDataSource, TDataType>(ISymmetricConvention<TDataSource, TDataType> convention, TDataSource data)
+        public static void Is<TDataSource>(ISymmetricConvention<TDataSource> convention, TDataSource data)
             where TDataSource : IConventionData
         {
             Is(convention, data, new ConventionResultExceptionReporter());
         }
 
-        public static void Is<TDataSource, TDataType>(ISymmetricConvention<TDataSource, TDataType> convention, TDataSource data, IConventionReportRenderer reporter)
+        public static void Is<TDataSource>(ISymmetricConvention<TDataSource> convention, TDataSource data, IConventionReportRenderer reporter)
             where TDataSource : IConventionData
         {
             try
@@ -108,7 +108,7 @@ public static void Is<TDataSource, TDataType>(ISymmetricConvention<TDataSource,
             }
         }
 
-        public static void IsWithApprovedExeptions<TDataSource, TDataType>(ISymmetricConvention<TDataSource, TDataType> convention, TDataSource data)
+        public static void IsWithApprovedExeptions<TDataSource>(ISymmetricConvention<TDataSource> convention, TDataSource data)
             where TDataSource : IConventionData
         {
             var conventionResult = GetConventionReport(convention.ConventionTitle, convention.GetFailingData(data).ToArray(), data);
diff --git a/TestStack.ConventionTests/Conventions/AllClassesHaveDefaultConstructor.cs b/TestStack.ConventionTests/Conventions/AllClassesHaveDefaultConstructor.cs
@@ -1,16 +1,15 @@
 ﻿namespace TestStack.ConventionTests.Conventions
 {
-    using System;
     using System.Collections.Generic;
     using System.Linq;
     using TestStack.ConventionTests.ConventionData;
     using TestStack.ConventionTests.Internal;
 
-    public class AllClassesHaveDefaultConstructor : IConvention<Types, Type>
+    public class AllClassesHaveDefaultConstructor : IConvention<Types>
     {
         public string ConventionTitle { get { return "Types must have a default constructor"; } }
 
-        public IEnumerable<Type> GetFailingData(Types data)
+        public IEnumerable<object> GetFailingData(Types data)
         {
             return data.TypesToVerify.Where(t => t.HasDefaultConstructor() == false);
         }
diff --git a/TestStack.ConventionTests/Conventions/AllMethodsAreVirtual.cs b/TestStack.ConventionTests/Conventions/AllMethodsAreVirtual.cs
@@ -6,11 +6,11 @@
     using TestStack.ConventionTests.ConventionData;
     using TestStack.ConventionTests.Internal;
 
-    public class AllMethodsAreVirtual : IConvention<Types, MethodInfo>
+    public class AllMethodsAreVirtual : IConvention<Types>
     {
         public string ConventionTitle { get { return "Methods must be virtual"; } }
 
-        public IEnumerable<MethodInfo> GetFailingData(Types data)
+        public IEnumerable<object> GetFailingData(Types data)
         {
             return data.TypesToVerify.SelectMany(t => t.NonVirtualMethods());
         }
diff --git a/TestStack.ConventionTests/Conventions/ClassTypeHasSpecificNamespace.cs b/TestStack.ConventionTests/Conventions/ClassTypeHasSpecificNamespace.cs
@@ -14,7 +14,7 @@
     /// 
     /// This is a Symmetric convention, and will verify all of a Class Type lives in the namespace, but also that only that class type is in that namespace
     /// </summary>
-    public class ClassTypeHasSpecificNamespace : ISymmetricConvention<Types, Type>
+    public class ClassTypeHasSpecificNamespace : ISymmetricConvention<Types>
     {
         readonly Func<Type, bool> classIsApplicable;
         readonly string namespaceToCheck;
@@ -49,14 +49,14 @@ public string InverseTitle
             }
         }
 
-        public IEnumerable<Type> GetFailingData(Types data)
+        public IEnumerable<object> GetFailingData(Types data)
         {
             return data.TypesToVerify
                 .Where(classIsApplicable)
                 .Where(t => t.Namespace == null || !t.Namespace.StartsWith(namespaceToCheck));
         }
 
-        public IEnumerable<Type> GetFailingInverseData(Types data)
+        public IEnumerable<object> GetFailingInverseData(Types data)
         {
             return data.TypesToVerify
                 .Where(t => !classIsApplicable(t))
diff --git a/TestStack.ConventionTests/Conventions/FilesAreEmbeddedResources.cs b/TestStack.ConventionTests/Conventions/FilesAreEmbeddedResources.cs
@@ -4,7 +4,7 @@
     using System.Linq;
     using TestStack.ConventionTests.ConventionData;
 
-    public class FilesAreEmbeddedResources : IConvention<ProjectFiles, ProjectFile>
+    public class FilesAreEmbeddedResources : IConvention<ProjectFiles>
     {
         public FilesAreEmbeddedResources(string fileExtension)
         {
@@ -21,7 +21,7 @@ public string ConventionTitle
 
         public string FileExtension { get; set; }
 
-        public IEnumerable<ProjectFile> GetFailingData(ProjectFiles data)
+        public IEnumerable<object> GetFailingData(ProjectFiles data)
         {
             return data.Files.Where(s => s.FilePath.EndsWith(FileExtension) && s.ReferenceType != "EmbeddedResource");
         }
diff --git a/TestStack.ConventionTests/Conventions/ISymmetricConvention.cs b/TestStack.ConventionTests/Conventions/ISymmetricConvention.cs
@@ -1,12 +1,12 @@
-﻿namespace TestStack.ConventionTests.Conventions
-{
-    using System.Collections.Generic;
-
-    public interface ISymmetricConvention<in T, out TDataType> where T : IConventionData
-    {
-        string ConventionTitle { get; }
-        string InverseTitle { get; }
-        IEnumerable<TDataType> GetFailingData(T data);
-        IEnumerable<TDataType> GetFailingInverseData(T data);
-    }
+﻿namespace TestStack.ConventionTests.Conventions
+{
+    using System.Collections.Generic;
+
+    public interface ISymmetricConvention<in T> where T : IConventionData
+    {
+        string ConventionTitle { get; }
+        string InverseTitle { get; }
+        IEnumerable<object> GetFailingData(T data);
+        IEnumerable<object> GetFailingInverseData(T data);
+    }
 }
diff --git a/TestStack.ConventionTests/Conventions/ProjectDoesNotReferenceDllsFromBinOrObjDirectories.cs b/TestStack.ConventionTests/Conventions/ProjectDoesNotReferenceDllsFromBinOrObjDirectories.cs
@@ -5,7 +5,7 @@
     using System.Text.RegularExpressions;
     using TestStack.ConventionTests.ConventionData;
 
-    public class ProjectDoesNotReferenceDllsFromBinOrObjDirectories : IConvention<ProjectReferences, ProjectReference>
+    public class ProjectDoesNotReferenceDllsFromBinOrObjDirectories : IConvention<ProjectReferences>
     {
         const string AssemblyReferencingObjRegex = @"^(?<assembly>.*?(obj|bin).*?)$";
 
@@ -16,7 +16,7 @@ static bool IsBinOrObjReference(ProjectReference reference)
 
         public string ConventionTitle { get { return "Project must not reference dlls from bin or obj directories"; } }
 
-        public IEnumerable<ProjectReference> GetFailingData(ProjectReferences data)
+        public IEnumerable<object> GetFailingData(ProjectReferences data)
         {
             return data.References.Where(IsBinOrObjReference);
         }
diff --git a/TestStack.ConventionTests/IConvention.cs b/TestStack.ConventionTests/IConvention.cs
@@ -2,9 +2,9 @@
 {
     using System.Collections.Generic;
 
-    public interface IConvention<in T, out TDataType> where T : IConventionData
+    public interface IConvention<in T> where T : IConventionData
     {
         string ConventionTitle { get; }
-        IEnumerable<TDataType> GetFailingData(T data);
+        IEnumerable<object> GetFailingData(T data);
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -34,10 +34,10 @@ public ConventionReportFailure Format(string failingData)`
`34`	`34`	`}`
`35`	`35`	`}`
`36`	`36`
`37`		`- public class FailingConvention : IConvention<FakeData, string>`
	`37`	`+ public class FailingConvention : IConvention<FakeData>`
`38`	`38`	`{`
`39`	`39`	`public string ConventionTitle { get { return "Header"; } }`
`40`		`- public IEnumerable<string> GetFailingData(FakeData data)`
	`40`	`+ public IEnumerable<object> GetFailingData(FakeData data)`
`41`	`41`	`{`
`42`	`42`	`return new[] {"Different"};`
`43`	`43`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,13 +31,13 @@ static Convention()`
`31`	`31`	`public static IEnumerable<ResultInfo> ConventionReports { get { return Reports; } }`
`32`	`32`	`public static IList<IReportDataFormatter> Formatters { get; private set; }`
`33`	`33`
`34`		`- public static void Is<TDataSource, TDataType>(IConvention<TDataSource, TDataType> convention, TDataSource data)`
	`34`	`+ public static void Is<TDataSource>(IConvention<TDataSource> convention, TDataSource data)`
`35`	`35`	`where TDataSource : IConventionData`
`36`	`36`	`{`
`37`	`37`	`Is(convention, data, new ConventionResultExceptionReporter());`
`38`	`38`	`}`
`39`	`39`
`40`		`- public static void Is<TDataSource, TDataType>(IConvention<TDataSource, TDataType> convention, TDataSource data, IConventionReportRenderer reporter)`
	`40`	`+ public static void Is<TDataSource>(IConvention<TDataSource> convention, TDataSource data, IConventionReportRenderer reporter)`
`41`	`41`	`where TDataSource : IConventionData`
`42`	`42`	`{`
`43`	`43`	`try`
`@@ -55,7 +55,7 @@ public static void Is<TDataSource, TDataType>(IConvention<TDataSource, TDataType`
`55`	`55`	`}`
`56`	`56`	`}`
`57`	`57`
`58`		`- public static void IsWithApprovedExeptions<TDataSource, TDataType>(IConvention<TDataSource, TDataType> convention, TDataSource data)`
	`58`	`+ public static void IsWithApprovedExeptions<TDataSource>(IConvention<TDataSource> convention, TDataSource data)`
`59`	`59`	`where TDataSource : IConventionData`
`60`	`60`	`{`
`61`	`61`	`var conventionResult = GetConventionReport(convention.ConventionTitle, convention.GetFailingData(data).ToArray(), data);`
`@@ -82,13 +82,13 @@ public static void IsWithApprovedExeptions<TDataSource, TDataType>(IConvention<T`
`82`	`82`	`}`
`83`	`83`	`}`
`84`	`84`
`85`		`- public static void Is<TDataSource, TDataType>(ISymmetricConvention<TDataSource, TDataType> convention, TDataSource data)`
	`85`	`+ public static void Is<TDataSource>(ISymmetricConvention<TDataSource> convention, TDataSource data)`
`86`	`86`	`where TDataSource : IConventionData`
`87`	`87`	`{`
`88`	`88`	`Is(convention, data, new ConventionResultExceptionReporter());`
`89`	`89`	`}`
`90`	`90`
`91`		`- public static void Is<TDataSource, TDataType>(ISymmetricConvention<TDataSource, TDataType> convention, TDataSource data, IConventionReportRenderer reporter)`
	`91`	`+ public static void Is<TDataSource>(ISymmetricConvention<TDataSource> convention, TDataSource data, IConventionReportRenderer reporter)`
`92`	`92`	`where TDataSource : IConventionData`
`93`	`93`	`{`
`94`	`94`	`try`
`@@ -108,7 +108,7 @@ public static void Is<TDataSource, TDataType>(ISymmetricConvention<TDataSource,`
`108`	`108`	`}`
`109`	`109`	`}`
`110`	`110`
`111`		`- public static void IsWithApprovedExeptions<TDataSource, TDataType>(ISymmetricConvention<TDataSource, TDataType> convention, TDataSource data)`
	`111`	`+ public static void IsWithApprovedExeptions<TDataSource>(ISymmetricConvention<TDataSource> convention, TDataSource data)`
`112`	`112`	`where TDataSource : IConventionData`
`113`	`113`	`{`
`114`	`114`	`var conventionResult = GetConventionReport(convention.ConventionTitle, convention.GetFailingData(data).ToArray(), data);`
Original file line number	Diff line number	Diff line change
`@@ -1,16 +1,15 @@`
`1`	`1`	`namespace TestStack.ConventionTests.Conventions`
`2`	`2`	`{`
`3`		`- using System;`
`4`	`3`	`using System.Collections.Generic;`
`5`	`4`	`using System.Linq;`
`6`	`5`	`using TestStack.ConventionTests.ConventionData;`
`7`	`6`	`using TestStack.ConventionTests.Internal;`
`8`	`7`
`9`		`- public class AllClassesHaveDefaultConstructor : IConvention<Types, Type>`
	`8`	`+ public class AllClassesHaveDefaultConstructor : IConvention<Types>`
`10`	`9`	`{`
`11`	`10`	`public string ConventionTitle { get { return "Types must have a default constructor"; } }`
`12`	`11`
`13`		`- public IEnumerable<Type> GetFailingData(Types data)`
	`12`	`+ public IEnumerable<object> GetFailingData(Types data)`
`14`	`13`	`{`
`15`	`14`	`return data.TypesToVerify.Where(t => t.HasDefaultConstructor() == false);`
`16`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,11 +6,11 @@`
`6`	`6`	`using TestStack.ConventionTests.ConventionData;`
`7`	`7`	`using TestStack.ConventionTests.Internal;`
`8`	`8`
`9`		`- public class AllMethodsAreVirtual : IConvention<Types, MethodInfo>`
	`9`	`+ public class AllMethodsAreVirtual : IConvention<Types>`
`10`	`10`	`{`
`11`	`11`	`public string ConventionTitle { get { return "Methods must be virtual"; } }`
`12`	`12`
`13`		`- public IEnumerable<MethodInfo> GetFailingData(Types data)`
	`13`	`+ public IEnumerable<object> GetFailingData(Types data)`
`14`	`14`	`{`
`15`	`15`	`return data.TypesToVerify.SelectMany(t => t.NonVirtualMethods());`
`16`	`16`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@`
`14`	`14`	`///`
`15`	`15`	`/// This is a Symmetric convention, and will verify all of a Class Type lives in the namespace, but also that only that class type is in that namespace`
`16`	`16`	`/// </summary>`
`17`		`- public class ClassTypeHasSpecificNamespace : ISymmetricConvention<Types, Type>`
	`17`	`+ public class ClassTypeHasSpecificNamespace : ISymmetricConvention<Types>`
`18`	`18`	`{`
`19`	`19`	`readonly Func<Type, bool> classIsApplicable;`
`20`	`20`	`readonly string namespaceToCheck;`
`@@ -49,14 +49,14 @@ public string InverseTitle`
`49`	`49`	`}`
`50`	`50`	`}`
`51`	`51`
`52`		`- public IEnumerable<Type> GetFailingData(Types data)`
	`52`	`+ public IEnumerable<object> GetFailingData(Types data)`
`53`	`53`	`{`
`54`	`54`	`return data.TypesToVerify`
`55`	`55`	`.Where(classIsApplicable)`
`56`	`56`	`.Where(t => t.Namespace == null \|\| !t.Namespace.StartsWith(namespaceToCheck));`
`57`	`57`	`}`
`58`	`58`
`59`		`- public IEnumerable<Type> GetFailingInverseData(Types data)`
	`59`	`+ public IEnumerable<object> GetFailingInverseData(Types data)`
`60`	`60`	`{`
`61`	`61`	`return data.TypesToVerify`
`62`	`62`	`.Where(t => !classIsApplicable(t))`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@`
`4`	`4`	`using System.Linq;`
`5`	`5`	`using TestStack.ConventionTests.ConventionData;`
`6`	`6`
`7`		`- public class FilesAreEmbeddedResources : IConvention<ProjectFiles, ProjectFile>`
	`7`	`+ public class FilesAreEmbeddedResources : IConvention<ProjectFiles>`
`8`	`8`	`{`
`9`	`9`	`public FilesAreEmbeddedResources(string fileExtension)`
`10`	`10`	`{`
`@@ -21,7 +21,7 @@ public string ConventionTitle`
`21`	`21`
`22`	`22`	`public string FileExtension { get; set; }`
`23`	`23`
`24`		`- public IEnumerable<ProjectFile> GetFailingData(ProjectFiles data)`
	`24`	`+ public IEnumerable<object> GetFailingData(ProjectFiles data)`
`25`	`25`	`{`
`26`	`26`	`return data.Files.Where(s => s.FilePath.EndsWith(FileExtension) && s.ReferenceType != "EmbeddedResource");`
`27`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@`
`5`	`5`	`using System.Text.RegularExpressions;`
`6`	`6`	`using TestStack.ConventionTests.ConventionData;`
`7`	`7`
`8`		`- public class ProjectDoesNotReferenceDllsFromBinOrObjDirectories : IConvention<ProjectReferences, ProjectReference>`
	`8`	`+ public class ProjectDoesNotReferenceDllsFromBinOrObjDirectories : IConvention<ProjectReferences>`
`9`	`9`	`{`
`10`	`10`	`const string AssemblyReferencingObjRegex = @"^(?<assembly>.?(obj\|bin).?)$";`
`11`	`11`
`@@ -16,7 +16,7 @@ static bool IsBinOrObjReference(ProjectReference reference)`
`16`	`16`
`17`	`17`	`public string ConventionTitle { get { return "Project must not reference dlls from bin or obj directories"; } }`
`18`	`18`
`19`		`- public IEnumerable<ProjectReference> GetFailingData(ProjectReferences data)`
	`19`	`+ public IEnumerable<object> GetFailingData(ProjectReferences data)`
`20`	`20`	`{`
`21`	`21`	`return data.References.Where(IsBinOrObjReference);`
`22`	`22`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,9 +2,9 @@`
`2`	`2`	`{`
`3`	`3`	`using System.Collections.Generic;`
`4`	`4`
`5`		`- public interface IConvention<in T, out TDataType> where T : IConventionData`
	`5`	`+ public interface IConvention<in T> where T : IConventionData`
`6`	`6`	`{`
`7`	`7`	`string ConventionTitle { get; }`
`8`		`- IEnumerable<TDataType> GetFailingData(T data);`
	`8`	`+ IEnumerable<object> GetFailingData(T data);`
`9`	`9`	`}`
`10`	`10`	`}`