public override void Execute(IAssert assert)
        {
            var data = SetUp();
            var typesToTest = GetTypesToTest(data);
            if (typesToTest.Length == 0)
            {
                assert.Inconclusive(
                    "No types found to apply the convention to. Make sure the Types predicate is correct and that the right assemblies to scan are specified.");
            }
            var invalidItems = Array.FindAll(typesToTest, t => data.Must(t) == false);

            var message = new StringBuilder();
            message.AppendLine(data.Description ?? "Invalid types found");
            foreach (var invalidType in invalidItems)
            {
                message.Append('\t');
                data.ItemDescription(invalidType, message);
            }
            if (data.HasApprovedExceptions)
            {
                Approve(message.ToString());
            }
            else
            {
                assert.AreEqual(0, invalidItems.Count(), message.ToString());
            }
        }

 public TestAttributionHandler(DeviceUtil deviceUtil, IAssert assert, TargetPlatform targetPlatform)
     : base(deviceUtil, assert)
 {
     TargetPlatform = targetPlatform;
     TestActivityPackage.Assert = Assert;
     TestActivityPackage.TargetPlatform = TargetPlatform;
 }

        public CategoryTestA(IAssert assert, ICategorize categorize)
        {
            _assert = assert;

            categorize.Method("Functional", TestMethodA);
            categorize.Method("Functional", TestMethodB);
        }

        public CPlusPlusSWIGBindingGeneratorWorksTest(IAssert assert, ICategorize categorize)
            : base(assert)
        {
            _assert = assert;

            categorize.Method("CPlusPlusPotentialSWIGInstallation", () => GenerationIsCorrect());
        }

        public CPlusPlusExternalPlatformReferenceWorksTest(IAssert assert, ICategorize categorize)
            : base(assert)
        {
            _assert = assert;

            categorize.Method("CPlusPlusPotentialSWIGInstallation", () => GenerationIsCorrect());
        }

 public static void Init(ILogger logger = null, IAssert assert = null,
     TimeoutSettings timeouts = null, IDriver<IWebDriver> driverFactory = null)
 {
     DriverFactory = driverFactory ?? new WebDriverFactory();
     Asserter = assert ?? new WebAssert();
     Timeouts = timeouts ?? new WebTimeoutSettings();
     Logger = logger ?? new LogAgregator(new NUnitLogger(), new Log4Net());
     MapInterfaceToElement.Init(DefaultInterfacesMap);
 }

        public static void InitFromProperties(ILogger logger = null, IAssert assert = null,
            TimeoutSettings timeouts = null, IDriver<IWebDriver> driverFactory = null)
        {
            Init(logger, assert, timeouts, driverFactory);
            JDISettings.InitFromProperties();
            FillFromSettings(p => Domain = p, "Domain");
            FillFromSettings(p => DriverFactory.DriverPath = p, "DriversFolder");

            // FillFromSettings(p => DriverFactory.DriverVersion = p, "DriversVersion");
            // fillAction(p->getDriverFactory().getLatestDriver =
            //        p.toLowerCase().equals("true") || p.toLowerCase().equals("1"), "driver.getLatest");
            // fillAction(p->asserter.doScreenshot(p), "screenshot.strategy");
            FillFromSettings(p =>
            {
                p = p.ToLower();
                if (p.Equals("soft"))
                    p = "any,multiple";
                if (p.Equals("strict"))
                    p = "visible,single";
                if (p.Split(',').Length != 2) return;
                var parameters = p.Split(',').ToList();
                if (parameters.Contains("visible") || parameters.Contains("displayed"))
                    WebDriverFactory.ElementSearchCriteria = el => el.Displayed;
                if (parameters.Contains("any") || parameters.Contains("all"))
                    WebDriverFactory.ElementSearchCriteria = el => el != null;
                if (parameters.Contains("single") || parameters.Contains("displayed"))
                    OnlyOneElementAllowedInSearch = true;
                if (parameters.Contains("multiple") || parameters.Contains("displayed"))
                    OnlyOneElementAllowedInSearch = false;
            }, "SearchElementStrategy");

            FillFromSettings(p =>
            {
                string[] split = null;
                if (p.Split(',').Length == 2)
                    split = p.Split(',');
                if (p.ToLower().Split('x').Length == 2)
                    split = p.ToLower().Split('x');
                if (split != null)
                    BrowserSize = new Size(Parse(split[0]), Parse(split[1]));
            }, "BrowserSize");
        }

 public PlatformSpecificXSLTGenerationWorksTest(IAssert assert)
     : base(assert)
 {
     _assert = assert;
 }

 public ModuleInfoGetsUpgradedTest(IAssert assert)
     : base(assert)
 {
     _assert = assert;
 }

 public NuGetAndroidDoesNotCrashTest(IAssert assert)
     : base(assert)
 {
     _assert = assert;
 }

 public MacOSPlatformForceAPIXamMacWorksTest(IAssert assert)
     : base(assert)
 {
     _assert = assert;
 }

 public PathUtilsTests(IAssert assert)
 {
     _assert = assert;
 }

 public BasicSynchronisationWorksTest(IAssert assert)
     : base(assert)
 {
 }

 public ExampleCocos2DXNATest(IAssert assert)
     : base(assert)
 {
     _assert = assert;
 }

 public IncludeProjectPropertiesWorksTest(IAssert assert)
     : base(assert)
 {
     _assert = assert;
 }

 public CheckForOverflowUnderflowPropertyWorksTest(IAssert assert)
     : base(assert)
 {
     _assert = assert;
 }

 public PackageTemplateAppliesCorrectlyTest(IAssert assert)
     : base(assert)
 {
     _assert = assert;
 }

 public PackageProtobuildHTTPResolvesSecondTimeForSourceAndBinaryTest(IAssert assert)
     : base(assert)
 {
     _assert = assert;
 }

 public PostBuildHookHasHostPlatformTest(IAssert assert)
     : base(assert)
 {
     _assert = assert;
 }

 public ServicesDisableTest(IAssert assert)
     : base(assert)
 {
     _assert = assert;
 }