public void InstanceTest()
        {
            try
            {
                InvisibleForm actual;

                actual = InvisibleForm.Instance;
                Assert.IsNotNull(actual, "InvisibleForm.Instance returned null");

                // Reset and try again
                PrivateType invisibleForm = new PrivateType(typeof(InvisibleForm));
                invisibleForm.SetStaticFieldOrProperty("instanceForm", null);

                actual = InvisibleForm.Instance;
                Assert.IsNotNull(actual, "InvisibleForm.Instance returned null");

                Assert.AreSame(actual, invisibleForm.GetStaticFieldOrProperty("instanceForm"), "Second call to the property should return the same opbject instance.");

                Form f = actual as Form;
                Assert.IsFalse(f.Visible, "InvisibleForm should not be visible");
            }
            catch (Exception ex)
            {
                // Use try catch to test a workaround on CI build (AppVeyor)
                Console.WriteLine(ex.Message);
            }
        }

        public void MyTestCleanup()
        {
            PrivateType privateWindowType = new PrivateType(typeof(VSWindows));
            privateWindowType.SetStaticFieldOrProperty("instance", null);

            this.serviceProvider = null;
        }

        public void KeyGenerationTest()
        {
            PrivateType pt = new PrivateType(typeof(AsymmetricBlobCryptoProvider));

            byte[] key = (byte[])pt.InvokeStatic("GenerateRandomKey");
            byte[] encryptedKey;
            byte[] decryptedKey;

            var rsa = new RSACryptoServiceProvider();
            rsa.ImportCspBlob(testCspBlob);

            using (ICspProxy cspProxy = new DisposingCspProxy(rsa, rsa.KeySize))
            {
                encryptedKey = cspProxy.Encrypt(key);
                decryptedKey = cspProxy.Decrypt(encryptedKey);
            }

            // The two keys shouldn't be the same...
            Assert.IsFalse(key.SequenceEqual(encryptedKey));

            // And we expect it to grow to the same size as the RSA Key
            Assert.IsTrue(encryptedKey.Length == 4096 / 8);

            // Sanity check, it should be 256 bit / 32 bytes and not contain any zeros.
            Assert.IsTrue(decryptedKey.Length == 256/8, "Key length is incorrect");
            Assert.IsTrue(decryptedKey[0] != 0, "Key starts with an empty byte");

            // And of course, the round tripped key should match original
            Assert.IsTrue(key.SequenceEqual(decryptedKey));
        }

        public void Init()
        {
            PrivateType p = new PrivateType(typeof(Dev2DataLanguageParser));
            var cache = p.GetStaticField("_expressionCache") as ConcurrentDictionary<string, IList<IIntellisenseResult>>;
            Assert.IsNotNull(cache);
            cache.Clear();
            var cache2 = p.GetStaticField("_payloadCache") as ConcurrentDictionary<Tuple<string, string>, IList<IIntellisenseResult>>;
            Assert.IsNotNull(cache2);
            cache2.Clear();
            Monitor.Enter(DataListSingletonTest.DataListSingletonTestGuard);

            var testEnvironmentModel = ResourceModelTest.CreateMockEnvironment();

            _resourceModel = new ResourceModel(testEnvironmentModel.Object)
            {
                ResourceName = "test",
                ResourceType = ResourceType.Service,
                DataList = @"
            <DataList>
                    <Scalar/>
                    <Country/>
                    <State />
                    <City>
                        <Name/>
                        <GeoLocation />
                    </City>
             </DataList>
            "
            };

            IDataListViewModel setupDatalist = new DataListViewModel();
            DataListSingleton.SetDataList(setupDatalist);
            DataListSingleton.ActiveDataList.InitializeDataListViewModel(_resourceModel);
        }

        public void Initialize()
        {
            PrivateType pt = new PrivateType(typeof(SQLiteRepositoryClient));
            pt.SetStaticField("dataSource", filename);

            wait = new AutoResetEvent(false);
        }

        public void GetPublicStaticPropertyValue()
        {
            dynamic subjectPO = new PrivateType<Subject>();

            bool actual = subjectPO.publicStaticProperty;

            Assert.IsFalse(actual);
        }

        public void TestGetApiURL()
        {
            PrivateType grinder = new PrivateType(typeof(MeatGrinder));
            PrivateObject obj = new PrivateObject(grinder);
            var retval = obj.Invoke("GetApiURL");

            Assert.AreEqual(1, 1);
        }

        public void GetPublicStaticFieldValue()
        {
            dynamic subjectPO = new PrivateType<Subject>();

            int actual = subjectPO.publicStaticField;

            Assert.AreEqual(Subject.FieldInitialValue, actual);
        }

 public void TestCountBulls()
 {
     bool[] isBull = new bool[4];
     PrivateType pr = new PrivateType(typeof(Game));
     pr.SetStaticFieldOrProperty("secretNumberAsString", "1234");
     int res = Game.CountBulls("1235", 0, isBull);
     Assert.AreEqual(3, res);
 }

 public void ReplaceNulls()
 {
     PrivateType internalAssertEx = new PrivateType(typeof(AssertEx));
     object oNull = null;
     Assert.AreEqual("(null)", internalAssertEx.InvokeStatic("ReplaceNulls", oNull), "AssertEx.ReplaceNulls didn't return the correct value.");
     Assert.AreEqual("teststring", internalAssertEx.InvokeStatic("ReplaceNulls", "teststring"), "AssertEx.ReplaceNulls didn't return the correct value.");
     Assert.AreEqual("test\\0string", internalAssertEx.InvokeStatic("ReplaceNulls", "test\0string"), "AssertEx.ReplaceNulls didn't return the correct value.");
 }

        protected TestBaseClass(object instanceToTest, Type typeToTest, int? presentationMethodID)
        {
            if (instanceToTest != null)
                InstanceToTest = new PrivateObject(instanceToTest);

            if (typeToTest != null)
                TypeToTest = new PrivateType(typeToTest);
        }

        public void InvokePrivateMethodThatReturnsBooleanWithParameter()
        {
            dynamic subjectPO = new PrivateType<Subject>();

            bool result = subjectPO.privateStaticMethodThatReturnsBooleanWithParameter(true);

            Assert.IsTrue(result);
        }

 /// <summary>
 /// Injects current UTC time as fixed constant as replacement of DateTime.UtcNow for testing purposes
 /// </summary>
 internal static void SetTestDateTime()
 {
     var moment = new PrivateType(typeof(Moment));
     var current = DateTime.UtcNow;
     // reduce precision to seconds, because Ticks may be extracted by SQL server
     DateTime precise = new DateTime(current.Year, current.Month, current.Day, current.Hour, current.Minute, current.Second);
     var customMoment = new InjectionDateTime { UtcNow = precise };
     moment.SetStaticField("service", customMoment);
 }

 public void TestIfCorrectNumbersOfMinesAreCreated()
 {
     PrivateType privateType = new PrivateType(typeof(GameBoardGenerator));
     var fieldSize = 1;
     int startRandomRange = ((15 * fieldSize * fieldSize) / 100) + 1;
     int endRandomRange = ((30 * fieldSize * fieldSize) / 100) + 1;
     int randomCheck = (int)privateType.InvokeStatic("RandomGenerator", startRandomRange, endRandomRange);
     Assert.IsTrue(randomCheck >= 1);
 }

        public void TestGetDestFilePath_NoExtensions()
        {
            const string expected = @"C:\Garmin\Activities\1990-01-01-00-00-00_duplicated";
            const string srcPath = @"C:\Garmin\Activities\1990-01-01-00-00-00";

            var pt = new PrivateType(typeof(Program));
            var actual = (string)pt.InvokeStatic("GetDestFilePath", new object[] { srcPath });

            Assert.AreEqual(expected, actual);
        }

        public void GetConfigurationIndependentPropertyPagesTest()
        {
            Guid[] expected = new Guid[] { typeof(GeneralPropertyPage).GUID };
            Guid[] actual;

            PrivateType type = new PrivateType(typeof(MyCustomProjectNode));
            PrivateObject obj = new PrivateObject(projectNode, type);
            actual = (Guid[])obj.Invoke("GetConfigurationIndependentPropertyPages", new object[] { });

            CollectionAssert.AreEqual(expected, actual, "IndependentPropertyPages not correctly set");
        }

 public void TestCountHits()
 {
     bool[] isBull = new bool[4];
     bool[] isCow = new bool[10];
     PrivateType pr = new PrivateType(typeof(Game));
     pr.SetStaticFieldOrProperty("secretNumberAsString", "1234");
     int bulls = Game.CountBulls("1234", 0, isBull);
     int cows = Game.CountCows("1234", 0, isBull, isCow);
     Assert.AreEqual(4, bulls);
     Assert.AreEqual(0, cows);
 }

        public void TestKernel()
        {
            var kernel = (IKernel)inboxWatcherPrivateObject.Invoke("ConfigureNinject");

            var pvtType = new PrivateType(typeof(InboxWatcher.InboxWatcher));
            var configs = (List <ImapMailBoxConfiguration> ) pvtType.InvokeStatic("GetConfigs");

            var client = kernel.Get<IImapFactory>(new ConstructorArgument("configuration", configs[0]));
            var imapMailBox = kernel.Get<IImapMailBox>(new ConstructorArgument("config", configs[0]));
            Debugger.Break();
        }

        public void V2MasterPasswordIsUniqueTest()
        {
            string key1 = CalculateNewMasterPasswordKey(MASTERPASSWORD);
            string key2 = CalculateNewMasterPasswordKey(MASTERPASSWORD);
            Assert.AreNotEqual(key1, key2, "generated master password key always equals.");

            var accessor = new PrivateType(typeof(PasswordFunctions2));
            byte[] keySalt = (byte[])accessor.InvokeStatic("CreateRandomKeySalt", new Object[] {});
            key1 = CalculateV2Key(accessor, keySalt);
            key2 = CalculateV2Key(accessor, keySalt);
            Assert.AreEqual(key1, key2, "generated master password doesn't equal.");
        }

 public void GameTestCurrentHits()
 {
     PrivateType pr = new PrivateType(typeof(Game));
     pr.SetStaticFieldOrProperty("secretNumberAsString", "1234");
     StringWriter sw = new StringWriter();
     Console.SetOut(sw);
     Game.RevealCurrentHits("1234");
     var result = sw.ToString();
     var expected = String.Format("Wrong number! Bulls: 4, Cows: 0!{0}{0}",
         Environment.NewLine);
     Assert.AreEqual(expected, result);
 }