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."); }
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 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 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 GetNextLine_X12LineAsDelimiter_CorrectDataReturned() { //arrange const int srcNo = 3; var LineFeederCreatePT = new PrivateType(typeof(LineFeederCreator)); var feeder = (LineFeederForSource)LineFeederCreatePT.InvokeStatic("CreateLineFeeder", new object[] { new StreamReader(_x12StreamLineAsDelimiter, Encoding.UTF8), srcNo, KindOfTextData.X12, false, false, "*", null }); //segment delimiter can be anything, but null here var tuplesFed = new List <Tuple <ExternalLine, int> >(); //act var tupleFed = feeder.GetNextLine(); while (tupleFed != null) { tuplesFed.Add(tupleFed); tupleFed = feeder.GetNextLine(); } //assert feeder.Should().BeOfType <X12FeederForSource>(); //note that segment delimiters are stripped out of segments tuplesFed.Count.Should().Be(37); tuplesFed[0].Item1.Text.Should().Be("ISA*01*0000000000*01*0000000000*ZZ*ABCDEFGHIJKLMNO*ZZ*123456789012345*101127*1719*U*00400*000003438*0*P*>\r"); tuplesFed[0].Item2.Should().Be(3); tuplesFed[1].Item1.Text.Should().Be("GS*PO*4405197800*999999999*20101127*1719*1421*X*004010VICS"); tuplesFed[1].Item2.Should().Be(3); tuplesFed[2].Item1.Text.Should().Be("ST*850*000000010"); tuplesFed[2].Item2.Should().Be(3); tuplesFed[4].Item1.Text.Should().Be("REF*DP*038"); tuplesFed[4].Item2.Should().Be(3); tuplesFed[7].Item1.Text.Should().Be("DTM*002*20101214"); tuplesFed[7].Item2.Should().Be(3); tuplesFed[9].Item1.Text.Should().Be("PKG*F*66***REGULAR"); tuplesFed[9].Item2.Should().Be(3); tuplesFed[12].Item1.Text.Should().Be("N3*31875 SOLON RD"); tuplesFed[12].Item2.Should().Be(3); tuplesFed[17].Item1.Text.Should().Be("PO1*2*220*EA*13.79*TE*CB*066850-116*PR*RO*VN*RD5322"); tuplesFed[17].Item2.Should().Be(3); tuplesFed[20].Item1.Text.Should().Be("PO1*3*126*EA*10.99*TE*CB*060733-110*PR*RO*VN*XY5266"); tuplesFed[20].Item2.Should().Be(3); tuplesFed[21].Item1.Text.Should().Be("PID*F****LARGE WIDGET"); tuplesFed[21].Item2.Should().Be(3); tuplesFed[26].Item1.Text.Should().Be("PO1*5*72*EA*7.5*TE*CB*065374-118*PR*RO*VN*RV0524"); tuplesFed[26].Item2.Should().Be(3); tuplesFed[28].Item1.Text.Should().Be("PO4*4*4*EA"); tuplesFed[28].Item2.Should().Be(3); tuplesFed[32].Item1.Text.Should().Be("CTT*6"); tuplesFed[32].Item2.Should().Be(3); tuplesFed[36].Item1.Text.Should().Be("IEA*1*000003438"); tuplesFed[36].Item2.Should().Be(3); }
public void GetMatchingDatabaseFieldAttribute_ShouldThrowException_WhenGivenPropertyWithoutAttribute() { try { PropertyInfo[] simpleProperty = (typeof(SimpleClass)).GetProperties(); PrivateType pt = new PrivateType(typeof(MatchingDatabaseFieldHelper)); pt.InvokeStatic("GetMatchingDatabaseFieldAttribute", simpleProperty[0]); } catch (TargetInvocationException ex) { throw ex.InnerException; } }
public void GetName_StaticMethodTest() { //arrange string name = "Abhishek"; int age = 30; Salary osalary = new Salary(name, age); //act PrivateType pType = new PrivateType(typeof(Salary)); string returnValue = pType.InvokeStatic("GetName", osalary) as string; //assert Assert.AreEqual(name, returnValue); }
public void TestGeoJsonToEsriGeometryPolygon() { var polyJson = TestResources.NorthCarolinaPolygonGeoJson; PrivateType pt = new PrivateType(typeof(GeometryClasses)); var poly = (IPolygon)pt.InvokeStatic("GeoJsonToEsriPolygon", polyJson); if (poly != null) { Assert.IsTrue(true); } }
public void TestTraffic() { // Test pilot traffic data string jsonString = System.IO.File.ReadAllText("edsmTraffic.json"); JObject response = JsonConvert.DeserializeObject <JObject>(jsonString); PrivateType starMapService = new PrivateType(typeof(StarMapService)); Dictionary <string, object> traffic = (Dictionary <string, object>)starMapService.InvokeStatic("ParseStarMapTraffic", new object[] { response }); Assert.IsNotNull(traffic); Assert.AreEqual(9631, (long?)traffic["total"]); Assert.AreEqual(892, (long?)traffic["week"]); Assert.AreEqual(193, (long?)traffic["day"]); }
public void TestDeaths() { // Test pilot mortality data string jsonString = System.IO.File.ReadAllText("edsmDeaths.json"); JObject response = JsonConvert.DeserializeObject <JObject>(jsonString); PrivateType starMapService = new PrivateType(typeof(StarMapService)); Dictionary <string, object> deaths = (Dictionary <string, object>)starMapService.InvokeStatic("ParseStarMapDeaths", new object[] { response }); Assert.IsNotNull(deaths); Assert.AreEqual(1068, (long?)deaths["total"]); Assert.AreEqual(31, (long?)deaths["week"]); Assert.AreEqual(4, (long?)deaths["day"]); }
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 HashPassword_ExampleString_returnEqual() { //arrange string password = "******"; byte[] expectedResult = { 161, 197, 195, 94, 68, 48, 156, 35, 26, 5, 53, 129, 72, 183, 200, 228, 65, 84, 166, 16, 193, 23, 17, 8, 130, 41, 177, 49, 198, 129, 144, 47 }; PrivateType type = new PrivateType(typeof(RSA)); //act byte[] result = (byte[])type.InvokeStatic("generateHash", new [] { password }); //assert CollectionAssert.AreEqual(expectedResult, result); }
public void GetMatchingDatabaseFieldAttribute_ShouldThrowException_WhenGivenNullProperty() { try { PropertyInfo nullProperty = default; PrivateType pt = new PrivateType(typeof(MatchingDatabaseFieldHelper)); pt.InvokeStatic("GetMatchingDatabaseFieldAttribute", nullProperty); } catch (TargetInvocationException ex) { throw ex.InnerException; } }
public void TestSerializeToString(string modelName) { ModelDoc2 doc = OpenSWDocument(modelName); LinkNode baseNode = Serialization.LoadBaseNodeFromModel(SwApp, doc, out bool error); Xunit.Assert.False(error); PrivateType serialization = new PrivateType(typeof(Serialization)); string newData = (string)serialization.InvokeStatic( "SerializeToString", new object[] { baseNode }); Xunit.Assert.NotNull(newData); Xunit.Assert.NotEmpty(newData); }
public void ParseBoolParameterTest() { var udf = new PrivateType(typeof(UserDefinedFunctions)); Assert.ThrowsException <ValidationError>( () => udf.InvokeStatic("ParseBoolParameter", "dummy", true)); Assert.IsTrue((bool)udf.InvokeStatic("ParseBoolParameter", "", true)); Assert.IsFalse((bool)udf.InvokeStatic("ParseBoolParameter", null, false)); Assert.IsTrue((bool)udf.InvokeStatic("ParseBoolParameter", "TRUE", false)); Assert.IsTrue((bool)udf.InvokeStatic("ParseBoolParameter", "true", false)); Assert.IsFalse((bool)udf.InvokeStatic("ParseBoolParameter", "FALSE", true)); Assert.IsFalse((bool)udf.InvokeStatic("ParseBoolParameter", "false", true)); }
public void SnLog_EventTypeProvider_Information() { var e = new Exception("E0"); e = new TestException_Warning("E1", e); e = new Exception("E2", e); e = new TestException_Information("E3", e); e = new Exception("E4", e); //"GetEventType", e var snLogAcc = new PrivateType(typeof(SnLog)); var actual = (TraceEventType)snLogAcc.InvokeStatic("GetEventType", e); Assert.AreEqual(TraceEventType.Information, actual); }
public void TruncateSelectedFields_AllFieldsNull_AddsNullValues() { Dictionary <BugField, string> bugFieldPairs = new Dictionary <BugField, string>(); BugInformation bugInfo = new BugInformation(); PrivateType privateAzureDevOpsBugReporting = new PrivateType(typeof(AzureDevOpsBugReporting)); privateAzureDevOpsBugReporting.InvokeStatic("TruncateSelectedFields", bugInfo, bugFieldPairs); Assert.AreEqual(4, bugFieldPairs.Count); Assert.IsNull(bugFieldPairs[BugField.ProcessName]); Assert.IsNull(bugFieldPairs[BugField.Glimpse]); Assert.IsNull(bugFieldPairs[BugField.TestMessages]); Assert.IsNull(bugFieldPairs[BugField.RuleSource]); }
public void Hermo_Parse_06() { var p = new PrivateType(typeof(Hermo)); var x = (HermoReading)p.InvokeStatic("ParseLine", "108D742C0208007237004B46FFFF031025"); Assert.AreEqual(0x720008022C748D10, x.Code); Assert.AreEqual(0x5E748512, x.Code32); Assert.AreEqual(0xDB66, x.Code16); Assert.AreEqual(0x10, x.FamilyId); Assert.AreEqual(0x0008022C748D, x.Serial); Assert.AreEqual(true, x.HasTemperature); Assert.AreEqual(27.25, x.Temperature); Assert.AreEqual(0.25, x.Resolution); }
public void Hermo_Parse_0x10_17() { var p = new PrivateType(typeof(Hermo)); var x = (HermoReading)p.InvokeStatic("ParseLine", "109A29130000003E09000705FFFF184EC4"); Assert.AreEqual(0x3E00000013299A10, x.Code); Assert.AreEqual(0x2D299A10, x.Code32); Assert.AreEqual(0xB739, x.Code16); Assert.AreEqual(0x10, x.FamilyId); Assert.AreEqual(0x00000013299A, x.Serial); Assert.AreEqual(true, x.HasTemperature); Assert.AreEqual(4.25, x.Temperature); Assert.AreEqual(0.25, x.Resolution); }
public void Hermo_Parse_01() { var p = new PrivateType(typeof(Hermo)); var x = (HermoReading)p.InvokeStatic("ParseLine", "108D6A45020800AF3A004B46FFFF0B102F"); Assert.AreEqual(unchecked ((Int64)0xAF000802456A8D10), x.Code); Assert.AreEqual(unchecked ((Int32)0xEA6A8512), x.Code32); Assert.AreEqual(0x6F78, x.Code16); Assert.AreEqual(0x10, x.FamilyId); Assert.AreEqual(0x000802456A8D, x.Serial); Assert.AreEqual(true, x.HasTemperature); Assert.AreEqual(28.75, x.Temperature); Assert.AreEqual(0.25, x.Resolution); }
public void Hermo_Parse_04() { var p = new PrivateType(typeof(Hermo)); var x = (HermoReading)p.InvokeStatic("ParseLine", "10C8DD540108007C2F004B46FFFF081078"); Assert.AreEqual(0x7C00080154DDC810, x.Code); Assert.AreEqual(0x28DDC011, x.Code32); Assert.AreEqual(0xE8CC, x.Code16); Assert.AreEqual(0x10, x.FamilyId); Assert.AreEqual(0x00080154DDC8, x.Serial); Assert.AreEqual(true, x.HasTemperature); Assert.AreEqual(23.25, x.Temperature); Assert.AreEqual(0.25, x.Resolution); }
public void TestLoadConfigFromStringXML(string modelName, int expNumLinks) { ModelDoc2 doc = OpenSWDocument(modelName); PrivateType serialization = new PrivateType(typeof(Serialization)); object swAttObj = serialization.InvokeStatic( "FindSWSaveAttribute", new object[] { doc, "URDF Export Configuration" }); Xunit.Assert.NotNull(swAttObj); Attribute swAtt = (Attribute)swAttObj; Parameter param = swAtt.GetParameter("data"); Xunit.Assert.NotNull(param); string data = param.GetStringValue(); Xunit.Assert.NotNull(data); Xunit.Assert.NotEmpty(data); LinkNode baseNode = (LinkNode)serialization.InvokeStatic( "LoadConfigFromStringXML", new object[] { data }); Link link = baseNode.GetLink(); Xunit.Assert.Equal(expNumLinks, Common.GetCount(link)); }
public void Hermo_Parse_07() { var p = new PrivateType(typeof(Hermo)); var x = (HermoReading)p.InvokeStatic("ParseLine", "2846185F0300003DC6014B467FFF0A1017"); Assert.AreEqual(0x3D0000035F184628, x.Code); Assert.AreEqual(0x6218462B, x.Code32); Assert.AreEqual(0x2433, x.Code16); Assert.AreEqual(0x28, x.FamilyId); Assert.AreEqual(0x0000035F1846, x.Serial); Assert.AreEqual(true, x.HasTemperature); Assert.AreEqual(28.375, x.Temperature); Assert.AreEqual(0.0625, x.Resolution); }
public void RollIPv4_UsingMethodWithAddressFamilyAsParameter_ReturnsValidIPv4() { //Arrange Regex regexForIPv4 = new Regex(@"^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$"); PrivateType IPGenerator_PrivateType = new PrivateType(typeof(IPGenerator)); object[] parameterValues = { 127 }; //Act var result = Convert.ToString(IPGenerator_PrivateType.InvokeStatic("RollIPv4", parameterValues)); //Assert Assert.IsTrue(regexForIPv4.IsMatch(result)); }
public void ApplyDecodingStepOnUnknownOperatorThrowsArgumentOutOfRangeException() { const string invalidOperator = "%"; try { var solverType = new PrivateType(typeof(ChallengeSolver)); solverType.InvokeStatic("ApplyDecodingStep", 323D, Tuple.Create(invalidOperator, 32D)); } //We're calling this with reflection, so we have to throw up the TargetInvocationException to represent what would actually occur. catch (TargetInvocationException e) { throw e.InnerException; } }
public void GetMappingElement_Scenerio_Result() { //------------Setup for test------------------------- var pr = new PrivateType(typeof(Dev2Logger)); var value = pr.InvokeStatic("GetMappingElement", "Level0", "ERROR"); //------------Execute Test--------------------------- //------------Assert Results------------------------- Assert.IsNotNull(value); Assert.IsNotNull(value); Assert.AreEqual(value.ToString(), @"<mapping> <level value=""Level0"" /> <eventLogEntryType value=""ERROR"" /> </mapping>"); }
public void Hermo_Parse_0x28_17() { var p = new PrivateType(typeof(Hermo)); var x = (HermoReading)p.InvokeStatic("ParseLine", "2824F76B000000872C014B467FFF041014"); Assert.AreEqual(unchecked ((Int64)0x870000006BF72428), x.Code); Assert.AreEqual(unchecked ((Int32)0xECF72428), x.Code32); Assert.AreEqual(0xC8DF, x.Code16); Assert.AreEqual(0x28, x.FamilyId); Assert.AreEqual(0x0000006BF724, x.Serial); Assert.AreEqual(true, x.HasTemperature); Assert.AreEqual(18.75, x.Temperature); Assert.AreEqual(0.0625, x.Resolution); }
public void Hermo_Parse_05() { var p = new PrivateType(typeof(Hermo)); var x = (HermoReading)p.InvokeStatic("ParseLine", "104C5F450208005139004B46FFFF0410F2"); Assert.AreEqual(0x51000802455F4C10, x.Code); Assert.AreEqual(0x145F4412, x.Code32); Assert.AreEqual(0x504D, x.Code16); Assert.AreEqual(0x10, x.FamilyId); Assert.AreEqual(0x000802455F4C, x.Serial); Assert.AreEqual(true, x.HasTemperature); Assert.AreEqual(28.25, x.Temperature); Assert.AreEqual(0.25, x.Resolution); }
public void TruncateSelectedFields_AllFieldsNull_AddsNullValues() { Dictionary <IssueField, string> issueFieldPairs = new Dictionary <IssueField, string>(); IssueInformation issueInfo = new IssueInformation(); PrivateType privateFileIssueHelpers = new PrivateType(typeof(FileIssueHelpers)); privateFileIssueHelpers.InvokeStatic("TruncateSelectedFields", issueInfo, issueFieldPairs); Assert.AreEqual(4, issueFieldPairs.Count); Assert.IsNull(issueFieldPairs[IssueField.ProcessName]); Assert.IsNull(issueFieldPairs[IssueField.Glimpse]); Assert.IsNull(issueFieldPairs[IssueField.TestMessages]); Assert.IsNull(issueFieldPairs[IssueField.RuleSource]); }
public void TestProgramMainAll() { PrivateType privateTypeObject = new PrivateType(typeof(Program)); privateTypeObject.InvokeStatic("ProcessInput", "c 5 3"); privateTypeObject.InvokeStatic("ProcessInput", "r 2 1 5 3"); privateTypeObject.InvokeStatic("ProcessInput", "b 2 2 o"); using (ConsoleOutput consoleOutput = new ConsoleOutput()) { privateTypeObject.InvokeStatic("ProcessInput", "l 3 1 3 3"); StringBuilder sb = new StringBuilder(); sb.Append("-------").Append(Environment.NewLine); sb.Append("|\0oxoo|").Append(Environment.NewLine); sb.Append("|\0ox\0o|").Append(Environment.NewLine); sb.Append("|\0oxoo|").Append(Environment.NewLine); sb.Append("-------"); string expected = sb.ToString(); Assert.AreEqual <string>(expected, consoleOutput.GetOutput().Trim()); } }
public void ExtractDataToConvertCorrectFormat() { StreamReader streamReader = MockStreamReaderService.MockContentFile("EUR;550;JPY"); DataToConvert dataToConvert = (DataToConvert)_privateType.InvokeStatic("ExtractDataToConvert", streamReader); Assert.AreEqual(dataToConvert.D1, "EUR"); Assert.AreEqual(dataToConvert.M, (uint)550); Assert.AreEqual(dataToConvert.D2, "JPY"); }
public void GetReportQueryNode_ValuesNodeNotEmpty_ReturnExpectedContent() { // Arrange var expectedText = $"({DummyString}Text = '{DummyString}' )"; var spWeb = new ShimSPWeb().Instance; var xmlNode = new ShimXmlNode(new XmlDocument()).Instance; var spList = new ShimSPList { FieldsGet = () => new ShimSPFieldCollection { GetFieldByInternalNameString = name => new ShimSPField { TypeGet = () => SPFieldType.User } } }.Instance; var privateType = new PrivateType(typeof(ReportingData)); ShimXmlDocument.AllInstances.NameGet = _ => "Contains"; ShimXmlNode.AllInstances.SelectSingleNodeString = (_, nodeName) => new ShimXmlNode(new XmlDocument()) { AttributesGet = () => new ShimXmlAttributeCollection { ItemOfGetString = attrName => new ShimXmlAttribute { ValueGet = () => "Dummy" } } }.Instance; ShimXmlNode.AllInstances.SelectNodesString = (_, name) => { var document = new XmlDocument(); var element = document.CreateElement("Dummy"); element.InnerText = "Dummy"; document.AppendChild(element); return(document.ChildNodes); }; var args = new object[] { spWeb, xmlNode, spList }; // Act var result = privateType.InvokeStatic(GetReportQueryNodeMethodName, args) as string; // Assert result.ShouldSatisfyAllConditions( () => result.ShouldNotBeNullOrEmpty(), () => result.ShouldBe(expectedText)); }
private void DoFailureTest(Dictionary <object[], string> testData, string method) { PrivateType fontConfigFile = new PrivateType(typeof(FontConfigFile)); foreach (var failure in testData) { try { fontConfigFile.InvokeStatic(method, failure.Key); } catch (Exception e) { Assert.AreEqual(failure.Value, e.Message); } } }
public void GetAddress_Given_Null_Source_And_NoRelativeUri_Should_Return_relativeUri() { //------------Setup for test------------------------- var webSource = new PrivateType(typeof(WebSources)); //------------Execute Test--------------------------- object[] args = { null, string.Empty }; var invokeStaticResults = webSource.InvokeStatic("GetAddress", args); //------------Assert Results------------------------- Assert.IsNotNull(invokeStaticResults); var results = invokeStaticResults as string; Assert.IsNotNull(results); Assert.IsTrue(string.IsNullOrEmpty(results)); }
public void WebSources_GetAddress_Given_Null_Source_And_relativeUri_Should_Return_relativeUri() { //------------Setup for test------------------------- var webSource = new PrivateType(typeof(WebSources)); //------------Execute Test--------------------------- object[] args = { null, "some url" }; var invokeStaticResults = webSource.InvokeStatic("GetAddress", args); //------------Assert Results------------------------- Assert.IsNotNull(invokeStaticResults); var results = invokeStaticResults as string; Assert.IsNotNull(results); Assert.AreEqual("some url", results); }
public void TestNullate01() { PrivateType nullateClass = new PrivateType(typeof(CFGtoCNF)); var production = CFGParser.Production("<S> -> <A> 'b' <B> [1]"); var nullableDictionary = new Dictionary<Nonterminal, double> { { Nonterminal.Of("A"), 0.5 }, { Nonterminal.Of("B"), 0.2 } }; var actualList = (List<Production>)nullateClass.InvokeStatic("Nullate", new object[] { production, nullableDictionary }); var actual = new HashSet<string>(actualList.Select((p) => p.ToString())); var expected = new HashSet<string> { CFGParser.Production("<S> -> <A> 'b' <B> [0.4]").ToString(), CFGParser.Production("<S> -> <A> 'b' [0.1]").ToString(), CFGParser.Production("<S> -> 'b' <B> [0.4]").ToString(), CFGParser.Production("<S> -> 'b' [0.1]").ToString(), }; Assert.IsTrue(actual.SetEquals(expected)); }
public void TestFlushDetection() { var handEvaluator = new PrivateType(typeof(HandEvaluator)); Assert.IsTrue((bool)handEvaluator.InvokeStatic("IsFlush", Flush.Cards), "Flush Error", "Failed to identify a flush."); Assert.IsFalse((bool)handEvaluator.InvokeStatic("IsFlush", StraightNoAce.Cards), "Flush Error", "Falsely identified a non flush hand as flush."); }
public void TestHandRankings() { var handEvaluator = new PrivateType(typeof(HandEvaluator)); Assert.AreEqual(9, (int)handEvaluator.InvokeStatic("GetHandType", StraightFlush.Cards), "Point Error", "Straight flush did not get the appropriate number of points"); Assert.AreEqual(8, (int)handEvaluator.InvokeStatic("GetHandType", FourOfAKindHighCard.Cards), "Point Error", "Four of a kind did not get the appropriate point value."); Assert.AreEqual(7, (int)handEvaluator.InvokeStatic("GetHandType", FullHouse.Cards), "Point Error", "Full house did not get the appropriate point value."); Assert.AreEqual(6, (int)handEvaluator.InvokeStatic("GetHandType", Flush.Cards), "Point Error", "Flush did not get the appropriate point value."); Assert.AreEqual(5, (int)handEvaluator.InvokeStatic("GetHandType", StraightNoAce.Cards), "Point Error", "Straight did not get the appropriate point value."); Assert.AreEqual(4, (int)handEvaluator.InvokeStatic("GetHandType", ThreeOfAKind.Cards), "Point Error", "Three of a kind did not get the appropriate point value."); Assert.AreEqual(3, (int)handEvaluator.InvokeStatic("GetHandType", TwoPair.Cards), "Point Error", "Two pair did not get the appropriate point value."); Assert.AreEqual(2, (int)handEvaluator.InvokeStatic("GetHandType", OnePair.Cards), "Point Error", "Pair did not get the appropriate point value."); Assert.AreEqual(1, (int)handEvaluator.InvokeStatic("GetHandType", HighCard.Cards), "Point Error", "High card did not get the appropriate point value."); }
public void NumberEncoder_Test() { PrivateType pt = new PrivateType(typeof(JpegImage)); short input = -1; ushort expected = 65534; // 11111111 11111110 ushort output = (ushort)pt.InvokeStatic("_numberEncoder", input); Assert.AreEqual(expected, output); }
public void Flush_Test() { PrivateType pt = new PrivateType(typeof(JpegImage)); BitList bl = new BitList(); bl.Add(true); bl.Add(true); bl.Add(false); byte[] output = (byte[]) pt.InvokeStatic("_flush", bl); byte[] expected = new byte[1] {192}; // 11000000 Assert.AreEqual(expected, output); }
public void Bitcost_Test() { PrivateType pt = new PrivateType(typeof(JpegImage)); short input = 2; byte expected = 2; byte output = (byte)pt.InvokeStatic("_bitCost", input); Assert.AreEqual(expected, output); }
public void UShortToBits_Test() { BitList bitList = new BitList(); ushort input = 3; byte inputLen = 2; PrivateType pt = new PrivateType(typeof(JpegImage)); pt.InvokeStatic("_ushortToBits", new object[] {bitList, input, inputLen}); BitList expectedBitList = new BitList(); expectedBitList.Add(true); expectedBitList.Add(true); Assert.AreEqual(expectedBitList, bitList); }
public void TestTwoPairDetection() { var handEvaluator = new PrivateType(typeof(HandEvaluator)); Assert.IsTrue((bool)handEvaluator.InvokeStatic("ContainsTwoPairs", TwoPair.Cards), "Two pair error", "Failed to detect two pairs in a hand."); Assert.IsFalse((bool)handEvaluator.InvokeStatic("ContainsTwoPairs", OnePair.Cards), "Two pair error", "Detected two pair when given one pair"); Assert.IsFalse((bool)handEvaluator.InvokeStatic("ContainsTwoPairs", HighCard.Cards), "Two pair error", "Detected a high card hand as two pairs."); }
public void SplitToChannels_Test() { Bitmap b = new Bitmap(2,2); b.SetPixel(0,0, Color.Black); // R = 0, G = 0, B = 0 b.SetPixel(1,0, Color.Green); // R = 0, G = 128, B = 0 b.SetPixel(0,1, Color.Red); // R = 128, G = 0, B = 0 b.SetPixel(1,1,Color.Blue); // R = 0, G = 0, B= 128 PrivateType pt = new PrivateType(typeof(JpegImage)); sbyte[][,] returnedChannels = (sbyte[][,])pt.InvokeStatic("_splitToChannels", b); sbyte[,] ch1 = { {-128, -51}, {-52, -98} }; sbyte[,] ch2 = { {0, -43}, {-42, 127} }; sbyte[,] ch3 = { {0, 127}, {-53, -20} }; sbyte[][,] expectedChannels = {ch1, ch2, ch3}; Assert.AreEqual(expectedChannels, returnedChannels); }
public void AddEdge_Test() { PrivateType pt = new PrivateType(typeof(JpegImage)); Vertex v1 = new Vertex(0, 1, 0, 4), v2 = new Vertex(2, 3, 2, 4), v3 = new Vertex(4, 5, 3, 4), v4 = new Vertex(6, 7, 3, 4), v5 = new Vertex(8, 9, 4, 4), v6 = new Vertex(10, 11, 5, 4); Graph inputGraph = new Graph(); inputGraph.Vertices.AddRange(new List<Vertex>() { v1, v2, v3, v4, v5, v6 }); int inputThreshold = 5; pt.InvokeStatic("_addEdge", new object[] {true, false, v1, v2, inputThreshold, inputGraph}); //pass pt.InvokeStatic("_addEdge", new object[] {true, true, v3, v4, inputThreshold, inputGraph}); //pass pt.InvokeStatic("_addEdge", new object[] {false, true, v5, v6, inputThreshold, inputGraph}); //fail Graph expectedGraph = new Graph(); expectedGraph.Edges.Add(new Edge(v1, v2, 3, true, false)); expectedGraph.Edges.Add(new Edge(v3, v4, 2, true, true)); Assert.AreEqual(expectedGraph.Edges, inputGraph.Edges); }
public void TestSetDetection() { var handEvaluator = new PrivateType(typeof(HandEvaluator)); Assert.IsTrue((bool)handEvaluator.InvokeStatic("ContainsSetOfSizeX", 4, FourOfAKindHighCard.Cards), "Set Identification error.", "Failed to properly identify a four of a kind."); Assert.IsFalse((bool)handEvaluator.InvokeStatic("ContainsSetOfSizeX", 2, StraightNoAce.Cards), "Set Identification error.", "Detected a two of a kind when given a straight."); }
public void Quantization_Test() { PrivateType pt = new PrivateType(typeof(JpegImage)); JpegImage ji = new JpegImage(new Bitmap(200, 100), 100, 4); float[,] inputValues = new float[8, 8]; int i = 0; for (int x = 0; x < 8; x++) //Fill input value with values from 0 to 63 { for (int y = 0; y < 8; y++) { inputValues[x, y] = i++; } } short[,] quantizedValues = (short[,]) pt.InvokeStatic("_quantization", new object[] {inputValues, ji.YQuantizationTable}); short[,] expectedQuantizedValues = new short[8, 8] { {0, 1, 2, 3, 2, 1, 1, 0}, {8, 9, 10, 5, 6, 3, 1, 1}, {16, 17, 9, 9, 5, 3, 2, 2}, {12, 12, 8, 9, 4, 3, 3, 2}, {10, 11, 6, 5, 4, 3, 3, 2}, {8, 5, 6, 4, 3, 3, 3, 3}, {8, 7, 6, 5, 4, 3, 3, 4}, {8, 9, 8, 8, 6, 5, 5, 5}, }; Assert.AreEqual(expectedQuantizedValues, quantizedValues); }
public void C_Test_i1_j1() { PrivateType pt = new PrivateType(typeof(JpegImage)); float returnedC = (float)pt.InvokeStatic("_c", new object[] { 1, 1 }); Assert.AreEqual(0.25f, returnedC); }
public void DiscreteCosineTransform_Test() { PrivateType pt = new PrivateType(typeof(JpegImage)); JpegImage ji = new JpegImage(new Bitmap(200, 100), 100, 4); float[,] inputBlock8 = new float[8, 8]; int i = 0; for (int x = 0; x < 8; x++) //Fill input value with values from 0 to 63 { for (int y = 0; y < 8; y++) { inputBlock8[x, y] = i++; } } float[,] returnedCosineValues = (float[,])pt.InvokeStatic("_discreteCosineTransform", inputBlock8); float[,] expectedCosineValues = new float[8, 8] { {252f, -18.220953f, -1.3045323E-07f, -1.90474725f, 1.78540418E-07f, -0.568218122f, -8.80875195E-09f, -0.143401206f}, {-145.767609f, 2.41847101E-06f, 8.53143945E-07f, 1.44885166E-06f, 1.03676985E-06f, -1.5390215E-07f, -2.55802661E-07f, -9.47974854E-08f}, {-2.99147609E-06f, 5.62151536E-06f, -1.10848976E-06f, -3.00187935E-07f, 2.10143571E-06f, -5.08922085E-07f, -6.90155488E-08f, 9.28238705E-07f}, {-15.2379627f, 4.95177403E-07f, -1.25386225E-06f, -2.32657641E-07f, -7.20322817E-07f, 4.82752E-07f, -1.97521246E-07f, 6.68256234E-07f}, {-1.72880823E-06f, -8.70578845E-07f, -7.59587181E-07f, 1.18702587E-06f, 2.07287385E-07f, 6.64636985E-08f, 1.24796173E-07f, -2.74013161E-07f}, {-4.54574156f, -2.06125083E-06f, 1.39842655E-06f, 5.91484728E-09f, -8.87210604E-07f, -3.22430438E-09f, 1.63273896E-07f, -2.61182095E-07f}, {5.71323699E-06f, 2.60522029E-06f, 4.07821602E-07f, 7.56153099E-07f, -8.28878115E-07f, 1.63273896E-07f, -2.87587607E-08f, 4.81403617E-07f}, {-1.1472187f, -1.5253089E-06f, 1.64349444E-06f, 4.29837684E-07f, -5.12431711E-07f, 8.11701511E-07f, 1.23775763E-07f, 7.26117264E-07f}, }; GlobalSettings.DefaultFloatingPointTolerance = 0.00001; Assert.That(expectedCosineValues, Is.EquivalentTo(returnedCosineValues)); }
public void Block16ToBlock8_Test() { PrivateType pt = new PrivateType(typeof(JpegImage)); float[,] inputValues = new float[16, 16]; int i = 0; for (int x = 0; x < 16; x++) //Fill input value with values from 0 to 255 { for (int y = 0; y < 16; y++) { inputValues[x, y] = i++; } } float[,] returnedBlock8 = (float[,]) pt.InvokeStatic("_block16ToBlock8", new object[] {inputValues, 1}); float[,] expectedBlock8 = new float[8, 8] { {128, 129f, 130f, 131f, 132f, 133f, 134f, 135f}, {144f, 145f, 146f, 147f, 148f, 149f, 150f, 151f}, {160f, 161f, 162f, 163f, 164f, 165f, 166f, 167f}, {176f, 177f, 178f, 179f, 180f, 181f, 182f, 183f}, {192f, 193f, 194f, 195f, 196f, 197f, 198f, 199f}, {208f, 209f, 210f, 211f, 212f, 213f, 214f, 215f}, {224f, 225f, 226f, 227f, 228f, 229f, 230f, 231f}, {240f, 241f, 242f, 243f, 244f, 245f, 246f, 247f}, }; Assert.AreEqual(expectedBlock8, returnedBlock8); }
public void DownSample_Test() { PrivateType pt = new PrivateType(typeof(JpegImage)); float[,] inputValues = new float[16, 16]; int i = 0; for (int x = 0; x < 16; x++) //Fill input value with values from 1 to 255 { for (int y = 0; y < 16; y++) { inputValues[x, y] = i++; } } float[,] downSampleValues = (float[,])pt.InvokeStatic("_downSample", inputValues); float[,] expectedDownSampledValues = new float[8, 8] { {8.5f, 10.5f, 12.5f, 14.5f, 16.5f, 18.5f, 20.5f, 22.5f}, {40.5f, 42.5f, 44.5f, 46.5f, 48.5f, 50.5f, 52.5f, 54.5f}, {72.5f, 74.5f, 76.5f, 78.5f, 80.5f, 82.5f, 84.5f, 86.5f}, {104.5f, 106.5f, 108.5f, 110.5f, 112.5f, 114.5f, 116.5f, 118.5f}, {136.5f, 138.5f, 140.5f, 142.5f, 144.5f, 146.5f, 148.5f, 150.5f}, {168.5f, 170.5f, 172.5f, 174.5f, 176.5f, 178.5f, 180.5f, 182.5f}, {200.5f, 202.5f, 204.5f, 206.5f, 208.5f, 210.5f, 212.5f, 214.5f}, {232.5f, 234.5f, 236.5f, 238.5f, 240.5f, 242.5f, 244.5f, 246.5f}, }; Assert.AreEqual(expectedDownSampledValues, downSampleValues); }
public void TestStraightDetection() { var handEvaluator = new PrivateType(typeof(HandEvaluator)); Assert.IsFalse((bool)handEvaluator.InvokeStatic("IsStraight", FourOfAKindHighCard.Cards), "Straight Error", "Evaluated a hand with duplicate values as straight."); Assert.IsTrue((bool)handEvaluator.InvokeStatic("IsStraight", StraightNoAce.Cards), "Straight Error", "Failed to detect a standard straight"); }
public void ForceSampleChange() { PrivateType pt = new PrivateType(typeof(JpegImage)); Vertex inputVertex = new Vertex(0, 1, 0, 4), expectedVertex = new Vertex(-1, 1, 0, 4); pt.InvokeStatic("_forceSampleChange", inputVertex); Assert.AreEqual(expectedVertex.ToString(), inputVertex.ToString()); }
public void RefactorGraph_Test() //TODO: fix this test { PrivateType pt = new PrivateType(typeof(JpegImage)); Vertex v1 = new Vertex(0, 1, 0, 4), v2 = new Vertex(2, 3, 2, 4), v3 = new Vertex(4, 5, 3, 4), v4 = new Vertex(6, 7, 3, 4), v5 = new Vertex(8, 9, 4, 4), v6 = new Vertex(10, 11, 5, 4); Edge e1 = new Edge(v1, v2, 1, true, false), e2 = new Edge(v3, v4, 2, true, true), e3 = new Edge(v5, v6, 2, false, true); Graph inputGraph = new Graph(); Graph sad = new Graph(); inputGraph.Edges.Add(e1); inputGraph.Edges.Add(e2); inputGraph.Edges.Add(e3); sad.Edges.Add(e1); sad.Edges.Add(e2); sad.Edges.Add(e3); sad.Vertices.AddRange(new List<Vertex>() { v1, v2, v3, v4, v5, v6 }); inputGraph.Vertices.AddRange(new List<Vertex>() { v1, v2, v3, v4, v5, v6 }); pt.InvokeStatic("_refactorGraph", inputGraph); Assert.AreEqual(sad.Vertices, inputGraph.Vertices); }
public void CopyBitmap_Test() { Bitmap b = new Bitmap(1, 1); b.SetPixel(0, 0, Color.Black); Bitmap testBitmapIn = new Bitmap(b, 200, 100); PrivateType pt = new PrivateType(typeof(JpegImage)); Bitmap copiedBitmap = (Bitmap)pt.InvokeStatic("_copyBitmap", new object[] {testBitmapIn, 200, 100}); Assert.AreEqual(testBitmapIn.GetPixel(100, 50), copiedBitmap.GetPixel(100, 50)); }
public void TestPrivates() { // Note how we test private instance method with PrivateObject // https://msdn.microsoft.com/en-us/library/microsoft.visualstudio.testtools.unittesting.privateobject.aspx var po = new PrivateObject(new SomeBusinessLogicClass()); Assert.AreEqual(3, po.Invoke("SomeInternalLogic", 1, 2)); // Note how we test private static methods with PrivateType // https://msdn.microsoft.com/en-us/library/microsoft.visualstudio.testtools.unittesting.privatetype.aspx var pt = new PrivateType(typeof(SomeBusinessLogicClass)); Assert.AreEqual(42, pt.InvokeStatic("SomeInternalStaticLogic")); // For PrivateObject and PrivateType, be VERY CAREFUL with parameters. // If you use the wrong type, you will get strange erros as methods // cannot be found. }
public void SwapVertexData() { PrivateType pt = new PrivateType(typeof(JpegImage)); Vertex inputV1 = new Vertex(0, 1, 0, 4), inputV2 = new Vertex(2, 3, 0, 4), expectedV1 = new Vertex(2, 1, 0, 4), expectedV2 = new Vertex(0, 3, 0, 4); Edge inputE1 = new Edge(inputV1, inputV2, 0, true, true), expectedE1 = new Edge(expectedV1, expectedV2, 0, true, true); pt.InvokeStatic("_swapVertexData", inputE1); Assert.AreEqual(expectedE1.ToString(), inputE1.ToString()); }
public async Task DatabaseTest() { // Note that this test really accesses a database. So we need a database // (localdb) on the build server. var pt = new PrivateType(typeof(SimpleOwinDatabaseSample.Startup)); var tables = await (pt.InvokeStatic("GetTableNamesAsync") as Task<IEnumerable<string>>); Assert.IsNotNull(tables); Assert.IsTrue(tables.Count() > 0); }